mso-api-handlers/mso-api-handler-infra/src/test/java/org/onap/so/apihandlerinfra/tenantisolation/process/ActivateVnfStatusOperationalEnvironmentTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. 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.onap.so.apihandlerinfra.tenantisolation.process;
  22
  23 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
  24 import static com.github.tomakehurst.wiremock.client.WireMock.post;
  25 import static com.github.tomakehurst.wiremock.client.WireMock.stubFor;
  26 import static com.github.tomakehurst.wiremock.client.WireMock.urlPathMatching;
  27 import static org.hamcrest.Matchers.startsWith;
  28 import static org.junit.Assert.assertEquals;
  29 import static org.junit.Assert.assertNotNull;
  30 import static org.junit.Assert.assertNull;
  31 import static org.junit.Assert.assertThat;
  32 import static org.junit.Assert.assertTrue;
  33
  34 import org.apache.http.HttpStatus;
  35 import org.json.JSONObject;
  36 import org.junit.After;
  37 import org.junit.Ignore;
  38 import org.junit.Rule;
  39 import org.junit.Test;
  40 import org.junit.rules.ExpectedException;
  41 import org.onap.so.apihandler.common.ErrorNumbers;
  42 import org.onap.so.apihandlerinfra.BaseTest;
  43 import org.onap.so.apihandlerinfra.exceptions.ApiException;
  44 import org.onap.so.apihandlerinfra.tenantisolation.CloudOrchestrationRequest;
  45 import org.onap.so.apihandlerinfra.tenantisolation.helpers.ActivateVnfDBHelper;
  46 import org.onap.so.apihandlerinfra.tenantisolationbeans.Distribution;
  47 import org.onap.so.apihandlerinfra.tenantisolationbeans.DistributionStatus;
  48 import org.onap.so.apihandlerinfra.tenantisolationbeans.Status;
  49 import org.onap.so.db.request.beans.InfraActiveRequests;
  50 import org.onap.so.db.request.beans.OperationalEnvDistributionStatus;
  51 import org.onap.so.db.request.beans.OperationalEnvServiceModelStatus;
  52 import org.onap.so.db.request.data.repository.InfraActiveRequestsRepository;
  53 import org.onap.so.db.request.data.repository.OperationalEnvDistributionStatusRepository;
  54 import org.onap.so.db.request.data.repository.OperationalEnvServiceModelStatusRepository;
  55 import org.springframework.beans.factory.annotation.Autowired;
  56
  57 public class ActivateVnfStatusOperationalEnvironmentTest extends BaseTest{
  58
  59         @Autowired
  60         private OperationalEnvDistributionStatusRepository distributionDbRepository;
  61         @Autowired
  62         private OperationalEnvServiceModelStatusRepository serviceModelDbRepository;
  63         @Autowired
  64         private ActivateVnfStatusOperationalEnvironment activateVnfStatus;
  65         @Autowired
  66         private InfraActiveRequestsRepository infraActiveRequestsRepository;
  67         @Autowired
  68         private ActivateVnfDBHelper dbHelper;
  69     @Rule
  70     public ExpectedException thrown = ExpectedException.none();
  71
  72         private String requestId = "TEST_requestId";
  73         private String requestIdOrig = "TEST_requestIdOrig";
  74         private String operationalEnvironmentId = "TEST_operationalEnvironmentId";
  75         private CloudOrchestrationRequest request = new CloudOrchestrationRequest();
  76         private String workloadContext = "TEST_workloadContext";
  77         private String recoveryActionRetry  = "RETRY";
  78         private String recoveryActionAbort  = "ABORT";
  79         private String recoveryActionSkip  = "SKIP";
  80         private String serviceModelVersionId = "TEST_serviceModelVersionId";
  81         private String serviceModelVersionId1 = "TEST_serviceModelVersionId1";
  82         private int retryCountThree = 3;
  83         private int retryCountTwo = 2;
  84         private int retryCountZero = 0;
  85         private String sdcDistributionId = "TEST_distributionId";
  86         private String sdcDistributionId1 = "TEST_distributionId1";
  87         private String statusOk = Status.DISTRIBUTION_COMPLETE_OK.toString();
  88         private String statusError = DistributionStatus.DISTRIBUTION_COMPLETE_ERROR.toString();
  89         private String statusSent = "SENT";
  90
  91         @After
  92         public void after() throws Exception {
  93                 distributionDbRepository.deleteAll();
  94                 serviceModelDbRepository.deleteAll();
  95         }
  96
  97         @Test
  98         public void checkOrUpdateOverallStatusTest_Ok() throws Exception {
  99
 100                 // two entries, both status Ok & retry 0
 101                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 102                 serviceModelDb.setRequestId(requestIdOrig);
 103                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 104                 serviceModelDb.setWorkloadContext(workloadContext);
 105                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 106                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 107                 serviceModelDb.setRetryCount(retryCountZero);
 108                 serviceModelDb.setServiceModelVersionDistrStatus(statusOk);
 109                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 110
 111                 serviceModelDb.setRequestId(requestIdOrig);
 112                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId1);
 113                 serviceModelDb.setWorkloadContext(workloadContext);
 114                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 115                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 116                 serviceModelDb.setRetryCount(retryCountZero);
 117                 serviceModelDb.setServiceModelVersionDistrStatus(statusOk);
 118                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 119
 120                 InfraActiveRequests iar = new InfraActiveRequests();
 121                 iar.setRequestId(requestIdOrig);
 122                 iar.setRequestStatus("PENDING");
 123                 infraActiveRequestsRepository.saveAndFlush(iar);
 124
 125                 activateVnfStatus.checkOrUpdateOverallStatus(operationalEnvironmentId, requestIdOrig, serviceModelDbRepository);
 126
 127                 // overall is success
 128                 InfraActiveRequests infraActiveRequest = infraActiveRequestsRepository.findOne(requestIdOrig);
 129                 assertNotNull(infraActiveRequest);
 130                 assertTrue(infraActiveRequest.getStatusMessage().contains("SUCCESSFUL"));
 131                 assertTrue(infraActiveRequest.getRequestStatus().contains("COMPLETE"));
 132
 133                 // cleanup
 134                 infraActiveRequestsRepository.delete(requestIdOrig);
 135         }
 136
 137         @Test
 138         public void checkOrUpdateOverallStatusTest_Error() throws Exception {
 139
 140                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 141                 serviceModelDb.setRequestId(requestIdOrig);
 142                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 143                 serviceModelDb.setWorkloadContext(workloadContext);
 144                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 145                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 146                 serviceModelDb.setRetryCount(retryCountZero);
 147                 serviceModelDb.setServiceModelVersionDistrStatus(statusError);
 148                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 149
 150                 InfraActiveRequests iar = new InfraActiveRequests();
 151                 iar.setRequestId(requestIdOrig);
 152                 iar.setRequestStatus("PENDING");
 153                 infraActiveRequestsRepository.saveAndFlush(iar);
 154
 155         try {
 156             activateVnfStatus.checkOrUpdateOverallStatus(operationalEnvironmentId, requestIdOrig, serviceModelDbRepository);
 157         }catch(ApiException e){
 158             assertThat(e.getMessage(), startsWith("Overall Activation process is a Failure. "));
 159             assertEquals(e.getHttpResponseCode(), HttpStatus.SC_BAD_REQUEST);
 160             assertEquals(e.getMessageID(), ErrorNumbers.SVC_DETAILED_SERVICE_ERROR);
 161         }
 162
 163                 // overall is failure
 164                 InfraActiveRequests infraActiveRequest = infraActiveRequestsRepository.findOne(requestIdOrig);
 165                 assertNotNull(infraActiveRequest);
 166                 assertTrue(infraActiveRequest.getStatusMessage().contains("FAILURE"));
 167                 assertTrue(infraActiveRequest.getRequestStatus().contains("FAILED"));
 168
 169                 // cleanup
 170                 infraActiveRequestsRepository.delete(requestIdOrig);
 171         }
 172
 173         @Test
 174         public void checkOrUpdateOverallStatusTest_Waiting() throws Exception {
 175
 176                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 177                 serviceModelDb.setRequestId(requestIdOrig);
 178                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 179                 serviceModelDb.setWorkloadContext(workloadContext);
 180                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 181                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 182                 serviceModelDb.setRetryCount(retryCountTwo);
 183                 serviceModelDb.setServiceModelVersionDistrStatus(statusError);
 184                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 185
 186                 activateVnfStatus.checkOrUpdateOverallStatus(operationalEnvironmentId, requestIdOrig, serviceModelDbRepository);
 187
 188                 // do nothing, waiting for more
 189                 assertNull(infraActiveRequestsRepository.findOne(requestIdOrig));
 190         }
 191
 192         @Test
 193         public void executionTest_Ok() throws Exception {
 194
 195                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 196                 serviceModelDb.setRequestId(requestIdOrig);
 197                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 198                 serviceModelDb.setWorkloadContext(workloadContext);
 199                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 200                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 201                 serviceModelDb.setRetryCount(retryCountThree);
 202                 serviceModelDb.setServiceModelVersionDistrStatus(statusSent);
 203                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 204
 205                 OperationalEnvDistributionStatus distributionDb = new OperationalEnvDistributionStatus();
 206                 distributionDb.setDistributionId(sdcDistributionId);
 207                 distributionDb.setRequestId(requestIdOrig);
 208                 distributionDb.setOperationalEnvId(operationalEnvironmentId);
 209                 distributionDb.setDistributionIdStatus(statusSent);
 210                 distributionDb.setServiceModelVersionId(serviceModelVersionId);
 211                 distributionDb.setDistributionIdErrorReason(null);
 212                 distributionDbRepository.saveAndFlush(distributionDb);
 213
 214
 215
 216                 // prepare distribution obj
 217                 Distribution distribution = new Distribution();
 218                 distribution.setStatus(Status.DISTRIBUTION_COMPLETE_OK);
 219                 request.setDistribution(distribution);
 220                 request.setDistributionId(sdcDistributionId);
 221                 request.setOperationalEnvironmentId(operationalEnvironmentId);
 222
 223                 InfraActiveRequests iar = new InfraActiveRequests();
 224                 iar.setRequestId(requestIdOrig);
 225                 iar.setRequestStatus("PENDING");
 226                 infraActiveRequestsRepository.saveAndFlush(iar);
 227
 228                 activateVnfStatus.execute(requestId, request, distributionDbRepository, serviceModelDbRepository);
 229
 230                 // status ok
 231                 OperationalEnvDistributionStatus distStatus = distributionDbRepository.findOne(sdcDistributionId);
 232                 assertNotNull(distStatus);
 233                 assertEquals(operationalEnvironmentId, distStatus.getOperationalEnvId());
 234                 assertEquals(statusOk, distStatus.getDistributionIdStatus());
 235                 assertEquals("", distStatus.getDistributionIdErrorReason());
 236
 237                 // status ok
 238                 OperationalEnvServiceModelStatus servStatus = serviceModelDbRepository.findOneByOperationalEnvIdAndServiceModelVersionId(operationalEnvironmentId, serviceModelVersionId);
 239                 assertNotNull(servStatus);
 240                 assertEquals(operationalEnvironmentId, servStatus.getOperationalEnvId());
 241                 assertEquals(statusOk, servStatus.getServiceModelVersionDistrStatus());
 242                 assertEquals(new Integer(retryCountZero), servStatus.getRetryCount());
 243
 244                 InfraActiveRequests infraActiveRequest = infraActiveRequestsRepository.findOne(requestIdOrig);
 245                 assertNotNull(infraActiveRequest);
 246                 assertTrue(infraActiveRequest.getStatusMessage().contains("SUCCESSFUL"));
 247                 assertTrue(infraActiveRequest.getRequestStatus().contains("COMPLETE"));
 248
 249                 // cleanup
 250                 infraActiveRequestsRepository.delete(requestIdOrig);
 251
 252         }
 253
 254         @Test
 255         public void executionTest_ERROR_Status_And_RETRY() throws Exception {
 256
 257                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 258                 serviceModelDb.setRequestId(requestIdOrig);
 259                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 260                 serviceModelDb.setWorkloadContext(workloadContext);
 261                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 262                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 263                 serviceModelDb.setRetryCount(retryCountThree);
 264                 serviceModelDb.setServiceModelVersionDistrStatus(statusError);
 265                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 266
 267                 OperationalEnvDistributionStatus distributionDb = new OperationalEnvDistributionStatus();
 268                 distributionDb.setDistributionId(sdcDistributionId);
 269                 distributionDb.setRequestId(requestIdOrig);
 270                 distributionDb.setOperationalEnvId(operationalEnvironmentId);
 271                 distributionDb.setDistributionIdStatus(statusError);
 272                 distributionDb.setServiceModelVersionId(serviceModelVersionId);
 273                 distributionDb.setDistributionIdErrorReason(null);
 274                 distributionDbRepository.saveAndFlush(distributionDb);
 275
 276
 277
 278                 // prepare new distribution obj
 279                 Distribution distribution = new Distribution();
 280                 distribution.setStatus(Status.DISTRIBUTION_COMPLETE_ERROR);
 281                 distribution.setErrorReason("Unable to process.");
 282                 request.setDistribution(distribution);
 283                 request.setDistributionId(sdcDistributionId);
 284                 request.setOperationalEnvironmentId(operationalEnvironmentId);
 285
 286                 // prepare sdc return data
 287                 JSONObject jsonObject = new JSONObject();
 288                 jsonObject.put("statusCode", "202");
 289                 jsonObject.put("message", "Success");
 290                 jsonObject.put("distributionId", sdcDistributionId1);
 291
 292                 stubFor(post(urlPathMatching("/sdc/v1/catalog/services/.*"))
 293                                 .willReturn(aResponse().withHeader("Content-Type", "application/json").withBody(jsonObject.toString()).withStatus(HttpStatus.SC_ACCEPTED)));
 294
 295                 activateVnfStatus.execute(requestId, request, distributionDbRepository, serviceModelDbRepository);
 296
 297                 // old distributionId, status error
 298                 OperationalEnvDistributionStatus distStatus = distributionDbRepository.findOne(sdcDistributionId);
 299                 assertNotNull(distStatus);
 300                 assertEquals(operationalEnvironmentId, distStatus.getOperationalEnvId());
 301                 assertEquals(statusError, distStatus.getDistributionIdStatus());
 302                 assertEquals("Unable to process.", distStatus.getDistributionIdErrorReason());
 303
 304                 // new distributionId, status sent
 305                 OperationalEnvDistributionStatus newDistStatus = distributionDbRepository.findOne(sdcDistributionId1);
 306                 assertNotNull(distStatus);
 307                 assertEquals(operationalEnvironmentId, newDistStatus.getOperationalEnvId());
 308                 assertEquals(statusSent, newDistStatus.getDistributionIdStatus());
 309                 assertEquals("", newDistStatus.getDistributionIdErrorReason());
 310
 311                 // count is less 1, status sent
 312                 OperationalEnvServiceModelStatus servStatus = serviceModelDbRepository.findOneByOperationalEnvIdAndServiceModelVersionId(operationalEnvironmentId, serviceModelVersionId);
 313                 assertNotNull(servStatus);
 314                 assertEquals(operationalEnvironmentId, servStatus.getOperationalEnvId());
 315                 assertEquals(statusSent, servStatus.getServiceModelVersionDistrStatus());
 316                 assertEquals(new Integer(retryCountTwo), servStatus.getRetryCount());
 317
 318                 // no update
 319                 assertNull(infraActiveRequestsRepository.findOne(requestIdOrig));
 320
 321         }
 322
 323         @Test
 324         public void executionTest_ERROR_Status_And_RETRY_And_RetryZero() throws Exception {
 325
 326                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 327                 serviceModelDb.setRequestId(requestIdOrig);
 328                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 329                 serviceModelDb.setWorkloadContext(workloadContext);
 330                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 331                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 332                 serviceModelDb.setRetryCount(retryCountZero);
 333                 serviceModelDb.setServiceModelVersionDistrStatus(statusError);
 334                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 335
 336                 OperationalEnvDistributionStatus distributionDb = new OperationalEnvDistributionStatus();
 337                 distributionDb.setDistributionId(sdcDistributionId);
 338                 distributionDb.setRequestId(requestIdOrig);
 339                 distributionDb.setOperationalEnvId(operationalEnvironmentId);
 340                 distributionDb.setDistributionIdStatus(statusError);
 341                 distributionDb.setServiceModelVersionId(serviceModelVersionId);
 342                 distributionDb.setDistributionIdErrorReason(null);
 343                 distributionDbRepository.saveAndFlush(distributionDb);
 344
 345
 346
 347                 // prepare distribution obj
 348                 Distribution distribution = new Distribution();
 349                 distribution.setStatus(Status.DISTRIBUTION_COMPLETE_ERROR);
 350                 request.setDistribution(distribution);
 351                 request.setDistributionId(sdcDistributionId);
 352                 request.setOperationalEnvironmentId(operationalEnvironmentId);
 353
 354                 JSONObject jsonObject = new JSONObject();
 355                 jsonObject.put("statusCode", "202");
 356                 jsonObject.put("message", "Success");
 357                 jsonObject.put("distributionId", sdcDistributionId);
 358
 359                 InfraActiveRequests iar = new InfraActiveRequests();
 360                 iar.setRequestId(requestIdOrig);
 361                 iar.setRequestStatus("PENDING");
 362                 infraActiveRequestsRepository.saveAndFlush(iar);
 363
 364                 stubFor(post(urlPathMatching("/sdc/v1/catalog/services/.*"))
 365                                 .willReturn(aResponse().withHeader("Content-Type", "application/json").withBody(jsonObject.toString()).withStatus(HttpStatus.SC_ACCEPTED)));
 366
 367         try {
 368             activateVnfStatus.execute(requestId, request, distributionDbRepository, serviceModelDbRepository);
 369         }catch(ApiException e){
 370             assertThat(e.getMessage(), startsWith("Overall Activation process is a Failure. "));
 371             assertEquals(e.getHttpResponseCode(), HttpStatus.SC_BAD_REQUEST);
 372             assertEquals(e.getMessageID(), ErrorNumbers.SVC_DETAILED_SERVICE_ERROR);
 373         }
 374
 375                 OperationalEnvDistributionStatus distStatus = distributionDbRepository.findOne(sdcDistributionId);
 376                 assertNotNull(distStatus);
 377                 assertEquals(operationalEnvironmentId, distStatus.getOperationalEnvId());
 378                 assertEquals(statusError, distStatus.getDistributionIdStatus());
 379                 assertEquals(null, distStatus.getDistributionIdErrorReason());
 380
 381                 OperationalEnvServiceModelStatus servStatus = serviceModelDbRepository.findOneByOperationalEnvIdAndServiceModelVersionId(operationalEnvironmentId, serviceModelVersionId);
 382                 assertNotNull(servStatus);
 383                 assertEquals(operationalEnvironmentId, servStatus.getOperationalEnvId());
 384                 assertEquals(statusError, servStatus.getServiceModelVersionDistrStatus());
 385                 assertEquals(new Integer(retryCountZero), servStatus.getRetryCount());
 386
 387                 // Retry count is zero, no more retry. all retry failed.
 388                 InfraActiveRequests infraActiveRequest = infraActiveRequestsRepository.findOne(requestIdOrig);
 389                 assertNotNull(infraActiveRequest);
 390                 assertTrue(infraActiveRequest.getStatusMessage().contains("FAILURE"));
 391                 assertTrue(infraActiveRequest.getRequestStatus().contains("FAILED"));
 392
 393                 // cleanup
 394                 infraActiveRequestsRepository.delete(requestIdOrig);
 395
 396         }
 397
 398         @Test
 399         public void executionTest_ERROR_Status_And_RETRY_And_ErrorSdc() throws Exception {
 400
 401                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 402                 serviceModelDb.setRequestId(requestIdOrig);
 403                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 404                 serviceModelDb.setWorkloadContext(workloadContext);
 405                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 406                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 407                 serviceModelDb.setRetryCount(retryCountThree);
 408                 serviceModelDb.setServiceModelVersionDistrStatus(statusError);
 409                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 410
 411                 OperationalEnvDistributionStatus distributionDb = new OperationalEnvDistributionStatus();
 412                 distributionDb.setDistributionId(sdcDistributionId);
 413                 distributionDb.setRequestId(requestIdOrig);
 414                 distributionDb.setOperationalEnvId(operationalEnvironmentId);
 415                 distributionDb.setDistributionIdStatus(statusError);
 416                 distributionDb.setServiceModelVersionId(serviceModelVersionId);
 417                 distributionDb.setDistributionIdErrorReason(null);
 418                 distributionDbRepository.saveAndFlush(distributionDb);
 419
 420
 421
 422                 // prepare distribution obj
 423                 Distribution distribution = new Distribution();
 424                 distribution.setStatus(Status.DISTRIBUTION_COMPLETE_ERROR);
 425                 distribution.setErrorReason("Unable to process.");
 426                 request.setDistribution(distribution);
 427                 request.setDistributionId(sdcDistributionId);
 428                 request.setOperationalEnvironmentId(operationalEnvironmentId);
 429
 430                 // ERROR in sdc
 431                 JSONObject jsonMessages = new JSONObject();
 432                 jsonMessages.put("statusCode", "409");
 433                 jsonMessages.put("message", "Undefined Error Message!");
 434                 jsonMessages.put("messageId", "SVC4675");
 435                 jsonMessages.put("text", "Error: Service state is invalid for this action.");
 436                 JSONObject jsonServException = new JSONObject();
 437                 jsonServException.put("serviceException", jsonMessages);
 438                 JSONObject jsonErrorRequest = new JSONObject();
 439                 jsonErrorRequest.put("requestError", jsonServException);
 440
 441                 InfraActiveRequests iar = new InfraActiveRequests();
 442                 iar.setRequestId(requestIdOrig);
 443                 iar.setRequestStatus("PENDING");
 444                 infraActiveRequestsRepository.saveAndFlush(iar);
 445
 446                 stubFor(post(urlPathMatching("/sdc/v1/catalog/services/.*"))
 447                                 .willReturn(aResponse().withHeader("Content-Type", "application/json").withBody(jsonMessages.toString()).withStatus(HttpStatus.SC_CONFLICT)));
 448
 449                 try {
 450             activateVnfStatus.execute(requestId, request, distributionDbRepository, serviceModelDbRepository);
 451         }catch(ApiException e){
 452             assertThat(e.getMessage(), startsWith("Failure calling SDC: statusCode: "));
 453             assertEquals(e.getHttpResponseCode(), HttpStatus.SC_BAD_REQUEST);
 454             assertEquals(e.getMessageID(), ErrorNumbers.SVC_DETAILED_SERVICE_ERROR);
 455         }
 456                 // status as-is / no changes
 457                 OperationalEnvDistributionStatus distStatus = distributionDbRepository.findOne(sdcDistributionId);
 458                 assertNotNull(distStatus);
 459                 assertEquals(operationalEnvironmentId, distStatus.getOperationalEnvId());
 460                 assertEquals(statusError, distStatus.getDistributionIdStatus());
 461                 assertEquals(null, distStatus.getDistributionIdErrorReason());
 462
 463                 // status as-is / no changes
 464                 OperationalEnvServiceModelStatus servStatus = serviceModelDbRepository.findOneByOperationalEnvIdAndServiceModelVersionId(operationalEnvironmentId, serviceModelVersionId);
 465                 assertNotNull(servStatus);
 466                 assertEquals(operationalEnvironmentId, servStatus.getOperationalEnvId());
 467                 assertEquals(statusError, servStatus.getServiceModelVersionDistrStatus());
 468                 assertEquals(new Integer(retryCountThree), servStatus.getRetryCount());
 469
 470                 InfraActiveRequests infraActiveRequest = infraActiveRequestsRepository.findOne(requestIdOrig);
 471                 assertNotNull(infraActiveRequest);
 472                 assertTrue(infraActiveRequest.getStatusMessage().contains("FAILURE"));
 473                 assertTrue(infraActiveRequest.getRequestStatus().contains("FAILED"));
 474                 assertTrue(infraActiveRequest.getStatusMessage().contains("Undefined Error Message!"));
 475
 476                 // cleanup
 477                 infraActiveRequestsRepository.delete(requestIdOrig);
 478
 479         }
 480
 481         @Test
 482         public void executionTest_ERROR_Status_And_SKIP() throws Exception {
 483
 484                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 485                 serviceModelDb.setRequestId(requestIdOrig);
 486                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 487                 serviceModelDb.setWorkloadContext(workloadContext);
 488                 serviceModelDb.setRecoveryAction(recoveryActionSkip);
 489                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 490                 serviceModelDb.setRetryCount(retryCountThree);
 491                 serviceModelDb.setServiceModelVersionDistrStatus(statusError);
 492                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 493
 494                 OperationalEnvDistributionStatus distributionDb = new OperationalEnvDistributionStatus();
 495                 distributionDb.setDistributionId(sdcDistributionId);
 496                 distributionDb.setRequestId(requestIdOrig);
 497                 distributionDb.setOperationalEnvId(operationalEnvironmentId);
 498                 distributionDb.setDistributionIdStatus(statusError);
 499                 distributionDb.setServiceModelVersionId(serviceModelVersionId);
 500                 distributionDb.setDistributionIdErrorReason(null);
 501                 distributionDbRepository.saveAndFlush(distributionDb);
 502
 503
 504
 505                 // prepare distribution obj
 506                 Distribution distribution = new Distribution();
 507                 distribution.setStatus(Status.DISTRIBUTION_COMPLETE_ERROR);
 508                 request.setDistribution(distribution);
 509                 request.setDistributionId(sdcDistributionId);
 510                 request.setOperationalEnvironmentId(operationalEnvironmentId);
 511
 512                 InfraActiveRequests iar = new InfraActiveRequests();
 513                 iar.setRequestId(requestIdOrig);
 514                 iar.setRequestStatus("PENDING");
 515                 infraActiveRequestsRepository.saveAndFlush(iar);
 516
 517                 activateVnfStatus.execute(requestId, request, distributionDbRepository, serviceModelDbRepository);
 518
 519                 InfraActiveRequests infraActiveRequest = infraActiveRequestsRepository.findOne(requestIdOrig);
 520                 assertNotNull(infraActiveRequest);
 521                 assertTrue(infraActiveRequest.getStatusMessage().contains("SUCCESSFUL"));
 522                 assertTrue(infraActiveRequest.getRequestStatus().contains("COMPLETE"));
 523
 524                 // cleanup
 525                 infraActiveRequestsRepository.delete(requestIdOrig);
 526
 527         }
 528
 529         @Test
 530         public void executionTest_ERROR_Status_And_ABORT() throws Exception {
 531
 532                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 533                 serviceModelDb.setRequestId(requestIdOrig);
 534                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 535                 serviceModelDb.setWorkloadContext(workloadContext);
 536                 serviceModelDb.setRecoveryAction(recoveryActionAbort);
 537                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 538                 serviceModelDb.setRetryCount(retryCountThree);
 539                 serviceModelDb.setServiceModelVersionDistrStatus(statusError);
 540                 serviceModelDbRepository.saveAndFlush(serviceModelDb);
 541
 542                 OperationalEnvDistributionStatus distributionDb = new OperationalEnvDistributionStatus();
 543                 distributionDb.setDistributionId(sdcDistributionId);
 544                 distributionDb.setRequestId(requestIdOrig);
 545                 distributionDb.setOperationalEnvId(operationalEnvironmentId);
 546                 distributionDb.setDistributionIdStatus(statusError);
 547                 distributionDb.setServiceModelVersionId(serviceModelVersionId);
 548                 distributionDb.setDistributionIdErrorReason(null);
 549                 distributionDbRepository.saveAndFlush(distributionDb);
 550
 551
 552
 553                 // prepare distribution obj
 554                 Distribution distribution = new Distribution();
 555                 distribution.setStatus(Status.DISTRIBUTION_COMPLETE_ERROR);
 556                 request.setDistribution(distribution);
 557                 request.setDistributionId(sdcDistributionId);
 558                 request.setOperationalEnvironmentId(operationalEnvironmentId);
 559
 560                 InfraActiveRequests iar = new InfraActiveRequests();
 561                 iar.setRequestId(requestIdOrig);
 562                 iar.setRequestStatus("PENDING");
 563                 infraActiveRequestsRepository.saveAndFlush(iar);
 564
 565         try {
 566             activateVnfStatus.execute(requestId, request, distributionDbRepository, serviceModelDbRepository);
 567         }catch(ApiException e){
 568             assertThat(e.getMessage(), startsWith("Overall Activation process is a Failure. "));
 569             assertEquals(e.getHttpResponseCode(), HttpStatus.SC_BAD_REQUEST);
 570             assertEquals(e.getMessageID(), ErrorNumbers.SVC_DETAILED_SERVICE_ERROR);
 571         }
 572
 573                 InfraActiveRequests infraActiveRequest = infraActiveRequestsRepository.findOne(requestIdOrig);
 574                 assertNotNull(infraActiveRequest);
 575                 assertTrue(infraActiveRequest.getStatusMessage().contains("FAILURE"));
 576                 assertTrue(infraActiveRequest.getRequestStatus().contains("FAILED"));
 577
 578                 // cleanup
 579                 infraActiveRequestsRepository.delete(requestIdOrig);
 580
 581         }
 582
 583         @Test
 584         @Ignore
 585         public void callSDClientForRetryTest_202() throws Exception {
 586                 OperationalEnvServiceModelStatus serviceModelDb = new OperationalEnvServiceModelStatus();
 587                 serviceModelDb.setRequestId(requestIdOrig);
 588                 serviceModelDb.setServiceModelVersionId(serviceModelVersionId);
 589                 serviceModelDb.setWorkloadContext(workloadContext);
 590                 serviceModelDb.setRecoveryAction(recoveryActionRetry);
 591                 serviceModelDb.setOperationalEnvId(operationalEnvironmentId);
 592                 serviceModelDb.setRetryCount(retryCountThree);
 593                 serviceModelDb.setServiceModelVersionDistrStatus(statusSent);
 594
 595                 OperationalEnvDistributionStatus distributionDb = new OperationalEnvDistributionStatus();
 596                 distributionDb.setDistributionId(sdcDistributionId);
 597                 distributionDb.setRequestId(requestIdOrig);
 598                 distributionDb.setOperationalEnvId(operationalEnvironmentId);
 599                 distributionDb.setDistributionIdStatus(statusSent);
 600                 distributionDb.setServiceModelVersionId(serviceModelVersionId);
 601                 distributionDb.setDistributionIdErrorReason(null);
 602
 603
 604
 605                 JSONObject jsonObject = new JSONObject();
 606                 jsonObject.put("statusCode", "202");
 607                 jsonObject.put("message", "Success");
 608                 jsonObject.put("distributionId", sdcDistributionId1);
 609
 610                 // prepare distribution obj
 611                 Distribution distribution = new Distribution();
 612                 distribution.setStatus(Status.DISTRIBUTION_COMPLETE_OK);
 613                 request.setDistribution(distribution);
 614                 request.setDistributionId(sdcDistributionId);
 615                 request.setOperationalEnvironmentId(operationalEnvironmentId);
 616
 617                 stubFor(post(urlPathMatching("/sdc/v1/catalog/services/TEST_serviceModelVersionId/distr.*"))
 618                                 .willReturn(aResponse().withHeader("Content-Type", "application/json").withBody(jsonObject.toString()).withStatus(HttpStatus.SC_ACCEPTED)));
 619
 620                 JSONObject jsonResponse = activateVnfStatus.callSDClientForRetry(distributionDb, serviceModelDb, distribution,
 621                                                                                                                         distributionDbRepository, serviceModelDbRepository);
 622
 623                 assertEquals("TEST_distributionId1", jsonResponse.get("distributionId"));
 624                 assertEquals("Success", jsonResponse.get("message"));
 625                 assertEquals("202", jsonResponse.get("statusCode"));
 626
 627                 // insert new record, status sent
 628                 OperationalEnvDistributionStatus distStatus = distributionDbRepository.findOne(sdcDistributionId1);
 629                 assertNotNull(distStatus);
 630                 assertEquals(operationalEnvironmentId, distStatus.getOperationalEnvId());
 631                 assertEquals(statusSent, distStatus.getDistributionIdStatus());
 632
 633                 // insert new record, status sent
 634                 OperationalEnvServiceModelStatus servStatus = serviceModelDbRepository.findOneByOperationalEnvIdAndServiceModelVersionId(operationalEnvironmentId, serviceModelVersionId);
 635                 assertNotNull(servStatus);
 636                 assertEquals(statusSent, servStatus.getServiceModelVersionDistrStatus());
 637                 assertEquals(operationalEnvironmentId, servStatus.getOperationalEnvId());
 638
 639         }
 640 }