test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/service/GetServiceLatestVersionTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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.openecomp.sdc.ci.tests.execute.service;
  22
  23 import com.google.gson.JsonArray;
  24 import com.google.gson.JsonElement;
  25 import com.google.gson.JsonParser;
  26 import org.junit.Rule;
  27 import org.junit.rules.TestName;
  28 import org.openecomp.sdc.be.dao.api.ActionStatus;
  29 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  30 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  31 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  32 import org.openecomp.sdc.be.model.Service;
  33 import org.openecomp.sdc.be.model.User;
  34 import org.openecomp.sdc.ci.tests.api.ComponentInstanceBaseTest;
  35 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  36 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  37 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  38 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
  39 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  40 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  41 import org.openecomp.sdc.ci.tests.utils.rest.*;
  42 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  43 import org.testng.annotations.BeforeMethod;
  44 import org.testng.annotations.Test;
  45
  46 import java.util.ArrayList;
  47 import java.util.List;
  48
  49 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION;
  50 import static org.testng.AssertJUnit.assertNull;
  51 import static org.testng.AssertJUnit.assertTrue;
  52
  53 public class GetServiceLatestVersionTest extends ComponentInstanceBaseTest {
  54
  55     protected ArtifactReqDetails heatArtifactDetails;
  56
  57     @Rule
  58     public static TestName name = new TestName();
  59
  60     public GetServiceLatestVersionTest() {
  61         super(name, GetServiceLatestVersionTest.class.getName());
  62     }
  63
  64     @BeforeMethod
  65     public void before() throws Exception {
  66         initMembers();
  67         createAtomicResource(resourceDetailsVFC_01);
  68         changeResourceStateToCertified(resourceDetailsVFC_01);
  69         createAtomicResource(resourceDetailsCP_01);
  70         changeResourceStateToCertified(resourceDetailsCP_01);
  71         createAtomicResource(resourceDetailsVL_01);
  72         changeResourceStateToCertified(resourceDetailsVL_01);
  73         createVF(resourceDetailsVF_01);
  74         certifyVf(resourceDetailsVF_01);
  75         createService(serviceDetails_01);
  76         createService(serviceDetails_02);
  77         createService(serviceDetails_03);
  78         createProduct(productDetails_01);
  79         createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_01, sdncDesignerDetails); // create
  80         // certified
  81         // VF
  82         // instance
  83         // in
  84         // service
  85         /*
  86          * RestResponse restResponse =
  87                  * LifecycleRestUtils.changeServiceState(serviceDetails_01,
  88                  * sdncDesignerDetails, LifeCycleStates.CHECKIN);
  89                  * ResourceRestUtils.checkSuccess(restResponse);
  90                  */
  91     }
  92
  93     public void initMembers() throws Exception {
  94         heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
  95         sdncPsDetails1 = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1);
  96         sdncPmDetails1 = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
  97         sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  98         sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  99         sdncTesterDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 100         resourceDetailsVFC_01 = ElementFactory.getDefaultResourceByType("VFC100", NormativeTypesEnum.COMPUTE,
 101                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(),
 102                 ResourceTypeEnum.VFC.toString()); // resourceType = VFC
 103         resourceDetailsVF_01 = ElementFactory.getDefaultResourceByType("VF100", NormativeTypesEnum.ROOT,
 104                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(),
 105                 ResourceTypeEnum.VF.toString());
 106         resourceDetailsCP_01 = ElementFactory.getDefaultResourceByType("CP100", NormativeTypesEnum.PORT,
 107                 ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, sdncDesignerDetails.getUserId(),
 108                 ResourceTypeEnum.CP.toString());
 109         resourceDetailsVL_01 = ElementFactory.getDefaultResourceByType("VL100", NormativeTypesEnum.NETWORK,
 110                 ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, sdncDesignerDetails.getUserId(),
 111                 ResourceTypeEnum.VL.toString());
 112         serviceDetails_01 = ElementFactory.getDefaultService("newtestservice1", ServiceCategoriesEnum.MOBILITY,
 113                                 sdncDesignerDetails.getUserId(), ServiceInstantiationType.A_LA_CARTE.getValue());
 114         serviceDetails_02 = ElementFactory.getDefaultService("newtestservice2", ServiceCategoriesEnum.MOBILITY,
 115                                 sdncDesignerDetails.getUserId(), ServiceInstantiationType.A_LA_CARTE.getValue());
 116         serviceDetails_03 = ElementFactory.getDefaultService("newtestservice3", ServiceCategoriesEnum.MOBILITY,
 117                                 sdncDesignerDetails.getUserId(), ServiceInstantiationType.A_LA_CARTE.getValue());
 118         productDetails_01 = ElementFactory.getDefaultProduct("product01");
 119     }
 120
 121     @Test
 122     public void getServicesLatestVersionServiceInCheckOutState() throws Exception {
 123         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncPsDetails1);
 124         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 125         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 126         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 127         assertNull("No Service returned, one service in checkout state 0.1", servcieFromList);
 128     }
 129
 130     @Test
 131     public void getServicesLatestVersionServiceInCheckInState() throws Exception {
 132         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 133                 LifeCycleStatesEnum.CHECKIN);
 134         ResourceRestUtils.checkSuccess(restResponse);
 135         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncPsDetails1);
 136         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 137         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 138         assertTrue(serviceList.size() == 1);
 139         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 140         assertTrue(servcieFromList.getVersion().equals("0.1"));
 141     }
 142
 143     @Test
 144     public void getServicesLatestVersionByPm() throws Exception {
 145         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 146                 LifeCycleStatesEnum.CHECKIN);
 147         ResourceRestUtils.checkSuccess(restResponse);
 148         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncPmDetails1);
 149         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 150         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 151         assertTrue(serviceList.size() == 1);
 152         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 153         assertTrue(servcieFromList.getVersion().equals("0.1"));
 154     }
 155
 156     @Test
 157     public void getServicesLatestVersionByAdmin() throws Exception {
 158         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 159                 LifeCycleStatesEnum.CHECKIN);
 160         ResourceRestUtils.checkSuccess(restResponse);
 161         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncAdminDetails);
 162         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 163         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 164         assertTrue(serviceList.size() == 1);
 165         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 166         assertTrue(servcieFromList.getVersion().equals("0.1"));
 167     }
 168
 169     @Test
 170     public void getServicesLatestVersionService02CheckOutState() throws Exception {
 171         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 172                 LifeCycleStatesEnum.CHECKIN);
 173         ResourceRestUtils.checkSuccess(restResponse);
 174         String serviceUniqueID = ResponseParser.getUniqueIdFromResponse(restResponse);
 175         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 176                 LifeCycleStatesEnum.CHECKOUT);
 177         ResourceRestUtils.checkSuccess(restResponse);
 178         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 179         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 180         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 181         assertTrue(serviceList.size() == 1);
 182         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceUniqueID);
 183         assertTrue(servcieFromList.getVersion().equals("0.1"));
 184         servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 185         assertNull(servcieFromList);
 186     }
 187
 188     @Test
 189     public void getServicesLatestVersionService02CheckInState() throws Exception {
 190         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 191                 LifeCycleStatesEnum.CHECKIN);
 192         ResourceRestUtils.checkSuccess(restResponse);
 193         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 194                 LifeCycleStatesEnum.CHECKOUT);
 195         ResourceRestUtils.checkSuccess(restResponse);
 196         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 197                 LifeCycleStatesEnum.CHECKIN);
 198         ResourceRestUtils.checkSuccess(restResponse);
 199         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 200         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 201         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 202         assertTrue(serviceList.size() == 1);
 203         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 204         assertTrue(servcieFromList.getVersion().equals("0.2"));
 205     }
 206
 207     @Test
 208     public void getServicesLatestVersionServiceWaitingForCertification() throws Exception {
 209         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 210                 LifeCycleStatesEnum.CHECKIN);
 211         ResourceRestUtils.checkSuccess(restResponse);
 212         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 213                 LifeCycleStatesEnum.CHECKOUT);
 214         ResourceRestUtils.checkSuccess(restResponse);
 215         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 216                 LifeCycleStatesEnum.CHECKIN);
 217         ResourceRestUtils.checkSuccess(restResponse);
 218         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 219                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 220         ResourceRestUtils.checkSuccess(restResponse);
 221         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 222         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 223         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 224         assertTrue(serviceList.size() == 1);
 225         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 226         assertTrue(servcieFromList.getVersion().equals("0.2"));
 227     }
 228
 229     @Test
 230     public void getServicesLatestVersionServiceCertificationInProgress() throws Exception {
 231         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 232                 LifeCycleStatesEnum.CHECKIN);
 233         ResourceRestUtils.checkSuccess(restResponse);
 234         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 235                 LifeCycleStatesEnum.CHECKOUT);
 236         ResourceRestUtils.checkSuccess(restResponse);
 237         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 238                 LifeCycleStatesEnum.CHECKIN);
 239         ResourceRestUtils.checkSuccess(restResponse);
 240         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 241                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 242         ResourceRestUtils.checkSuccess(restResponse);
 243         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
 244                 LifeCycleStatesEnum.STARTCERTIFICATION);
 245         ResourceRestUtils.checkSuccess(restResponse);
 246         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 247         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 248         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 249         assertTrue(serviceList.size() == 1);
 250         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 251         assertTrue(servcieFromList.getVersion().equals("0.2"));
 252     }
 253
 254     @Test
 255     public void getServicesLatestVersionServiceCertificationFail() throws Exception {
 256         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 257                 LifeCycleStatesEnum.CHECKIN);
 258         ResourceRestUtils.checkSuccess(restResponse);
 259         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 260                 LifeCycleStatesEnum.CHECKOUT);
 261         ResourceRestUtils.checkSuccess(restResponse);
 262         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 263                 LifeCycleStatesEnum.CHECKIN);
 264         ResourceRestUtils.checkSuccess(restResponse);
 265         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 266                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 267         ResourceRestUtils.checkSuccess(restResponse);
 268         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
 269                 LifeCycleStatesEnum.STARTCERTIFICATION);
 270         ResourceRestUtils.checkSuccess(restResponse);
 271         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
 272                 LifeCycleStatesEnum.FAILCERTIFICATION);
 273         ResourceRestUtils.checkSuccess(restResponse);
 274         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 275         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 276         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 277         assertTrue(serviceList.size() == 1);
 278         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 279         assertTrue(servcieFromList.getVersion().equals("0.2"));
 280     }
 281
 282     @Test
 283     public void getServicesLatestVersionServiceCertifed() throws Exception {
 284         certifyService(serviceDetails_01);
 285         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 286         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 287         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 288         assertTrue(serviceList.size() == 1);
 289         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 290         assertTrue(servcieFromList.getVersion().equals("1.0"));
 291     }
 292
 293     @Test
 294     public void getLatestVersionServiceHasSeveralCertifedVersion_01() throws Exception {
 295         RestResponse certifyServiceResponse;
 296         String serviceUniqueIdFromResponse = null;
 297         int numberOfCertifiedService = 3;
 298         for (int i = 0; i < numberOfCertifiedService; i++) {
 299             certifyServiceResponse = certifyService(serviceDetails_01);
 300             ServiceRestUtils.checkSuccess(certifyServiceResponse);
 301             if (i == (numberOfCertifiedService - 1)) {
 302                 serviceUniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(certifyServiceResponse);
 303             }
 304             RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 305                     LifeCycleStatesEnum.CHECKOUT);
 306             ServiceRestUtils.checkSuccess(restResponse);
 307         }
 308         // We have service with following versions : 1.0, 2.0 ,3.0 and
 309         // 3.1(checkedOut)
 310         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 311         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 312         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 313         assertTrue(serviceList.size() == 1);
 314         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceUniqueIdFromResponse);
 315         assertTrue(servcieFromList.getVersion().equals("3.0"));
 316     }
 317
 318     @Test
 319     public void getLatestVersionServiceHasSeveralCertifedVersions02() throws Exception {
 320         RestResponse certifyServiceResponse;
 321         certifyServiceResponse = certifyService(serviceDetails_01);
 322         ServiceRestUtils.checkSuccess(certifyServiceResponse);
 323         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 324                 LifeCycleStatesEnum.CHECKOUT);
 325         ServiceRestUtils.checkSuccess(restResponse);
 326         certifyServiceResponse = certifyService(serviceDetails_01);
 327         ServiceRestUtils.checkSuccess(certifyServiceResponse);
 328         // We have service with following versions : 1.0, 2.0
 329         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 330         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 331         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 332         assertTrue(serviceList.size() == 1);
 333         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 334         assertTrue(servcieFromList.getVersion().equals("2.0"));
 335     }
 336
 337     @Test
 338     public void getLatestVersionServiceCertifedWasCheckedOutAndCheckedin() throws Exception {
 339         RestResponse certifyServiceResponse;
 340         int numberOfCertifiedService = 3;
 341         for (int i = 0; i < numberOfCertifiedService; i++) {
 342             certifyServiceResponse = certifyService(serviceDetails_01);
 343             ServiceRestUtils.checkSuccess(certifyServiceResponse);
 344             RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 345                     LifeCycleStatesEnum.CHECKOUT);
 346             ServiceRestUtils.checkSuccess(restResponse);
 347         }
 348         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 349                 LifeCycleStatesEnum.CHECKIN);
 350         ServiceRestUtils.checkSuccess(restResponse);
 351         // We have service with following versions : 1.0, 2.0 and 2.1(checkedIn)
 352         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 353         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 354         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 355         assertTrue(serviceList.size() == 1);
 356         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 357         assertTrue(servcieFromList.getVersion().equals("3.1"));
 358     }
 359
 360     @Test
 361     public void getLatestVersionServiceCheckOutCertifedService() throws Exception {
 362         RestResponse restResponse;
 363         String serviceUniqueIdFromResponse = null;
 364         RestResponse certifyServiceResponse = certifyService(serviceDetails_01);
 365         ServiceRestUtils.checkSuccess(certifyServiceResponse);
 366         for (int i = 0; i < 11; i++) {
 367             restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 368                     LifeCycleStatesEnum.CHECKOUT);
 369             ServiceRestUtils.checkSuccess(restResponse);
 370             restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 371                     LifeCycleStatesEnum.CHECKIN);
 372             ServiceRestUtils.checkSuccess(restResponse);
 373             if (i == (10)) {
 374                 serviceUniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(restResponse);
 375             }
 376         }
 377         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 378                 LifeCycleStatesEnum.CHECKOUT);
 379         ServiceRestUtils.checkSuccess(restResponse);
 380         // We have service with following versions : 1.0 and 1.11(Check-out)
 381         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 382         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 383         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 384         assertTrue(serviceList.size() == 1);
 385         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceUniqueIdFromResponse);
 386         assertTrue(servcieFromList.getVersion().equals("1.11"));
 387     }
 388
 389     @Test
 390     public void getLatestVersionServiceCheckOutCheckInCertifedService() throws Exception {
 391         RestResponse restResponse;
 392         String serviceUniqueIdFromResponse = null;
 393         RestResponse certifyServiceResponse = certifyService(serviceDetails_01);
 394         ServiceRestUtils.checkSuccess(certifyServiceResponse);
 395         for (int i = 0; i < 12; i++) {
 396             restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 397                     LifeCycleStatesEnum.CHECKOUT);
 398             ServiceRestUtils.checkSuccess(restResponse);
 399             restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 400                     LifeCycleStatesEnum.CHECKIN);
 401             ServiceRestUtils.checkSuccess(restResponse);
 402             if (i == (11)) {
 403                 serviceUniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(restResponse);
 404             }
 405         }
 406         // We have service with following versions : 1.0 and 1.11(Check-out)
 407         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 408         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 409         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 410         assertTrue(serviceList.size() == 1);
 411         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceUniqueIdFromResponse);
 412         assertTrue(servcieFromList.getVersion().equals("1.12"));
 413     }
 414
 415     @Test
 416     public void getLatestVersionServiceCertifedCheckedOutAndInWaitingForCertificationState() throws Exception {
 417         certifyService(serviceDetails_01); // 1.0
 418         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 419                 LifeCycleStatesEnum.CHECKOUT);
 420         ServiceRestUtils.checkSuccess(restResponse);
 421         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 422                 LifeCycleStatesEnum.CHECKIN);
 423         ServiceRestUtils.checkSuccess(restResponse);
 424         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 425                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 426         ServiceRestUtils.checkSuccess(restResponse);
 427         // We have service with following versions : 1.0 and 1.1(Waiting For
 428         // Certification)
 429         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 430         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 431         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 432         assertTrue(serviceList.size() == 1);
 433         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 434         assertTrue(servcieFromList.getVersion().equals("1.1"));
 435     }
 436
 437     @Test
 438     public void getLatestVersionServiceCertifedCheckedOutAndInCertificationInProgressState() throws Exception {
 439         certifyService(serviceDetails_01); // 1.0
 440         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 441                 LifeCycleStatesEnum.CHECKOUT);
 442         ServiceRestUtils.checkSuccess(restResponse);
 443         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 444                 LifeCycleStatesEnum.CHECKIN);
 445         ServiceRestUtils.checkSuccess(restResponse);
 446         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 447                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 448         ServiceRestUtils.checkSuccess(restResponse);
 449         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
 450                 LifeCycleStatesEnum.STARTCERTIFICATION);
 451         ServiceRestUtils.checkSuccess(restResponse);
 452         // We have service with following versions : 1.0 and 1.1(Certification
 453         // In Progress)
 454         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 455         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 456         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 457         assertTrue(serviceList.size() == 1);
 458         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 459         assertTrue(servcieFromList.getVersion().equals("1.1"));
 460     }
 461
 462     // DE190818
 463     @Test(enabled = false)
 464     public void getLatestVersionByNonAsdcUser() throws Exception {
 465         User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 466         nonAsdcUser.setUserId("gg750g");
 467         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(nonAsdcUser);
 468         assertTrue(getServicesLatestVersion.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 469         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 470                 getServicesLatestVersion.getResponse());
 471     }
 472
 473     // DE190818
 474     @Test(enabled = false)
 475     public void getLatestVersionUserIdIsEmpty() throws Exception {
 476         User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 477         nonAsdcUser.setUserId("");
 478         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(nonAsdcUser);
 479         assertTrue(getServicesLatestVersion.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 480         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 481                 getServicesLatestVersion.getResponse());
 482     }
 483
 484     @Test
 485     public void getServicesLatestVersionByTester() throws Exception {
 486         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 487                 LifeCycleStatesEnum.CHECKIN);
 488         ResourceRestUtils.checkSuccess(restResponse);
 489         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncTesterDetails);
 490         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 491         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 492         assertTrue(serviceList.size() == 1);
 493         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_01.getUniqueId());
 494         assertTrue(servcieFromList.getVersion().equals("0.1"));
 495     }
 496
 497     @Test
 498     public void getLatestVersionSeveralServicesInDifferentVersion() throws Exception {
 499         RestResponse restResponse = certifyService(serviceDetails_01); // 1.0
 500         ServiceRestUtils.checkSuccess(restResponse);
 501         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 502                 LifeCycleStatesEnum.CHECKOUT);
 503         ServiceRestUtils.checkSuccess(restResponse);
 504         restResponse = certifyService(serviceDetails_01);
 505         ServiceRestUtils.checkSuccess(restResponse);
 506         String service1_UniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(restResponse);
 507         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 508                 LifeCycleStatesEnum.CHECKOUT);
 509         ServiceRestUtils.checkSuccess(restResponse); // serviceDetails_01
 510         // version is 2.1
 511         // (check-out)
 512
 513         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_02, sdncDesignerDetails,
 514                 LifeCycleStatesEnum.CHECKIN);
 515         ServiceRestUtils.checkSuccess(restResponse);
 516         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_02, sdncDesignerDetails,
 517                 LifeCycleStatesEnum.CHECKOUT);
 518         ServiceRestUtils.checkSuccess(restResponse);
 519         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_02, sdncDesignerDetails,
 520                 LifeCycleStatesEnum.CHECKIN);
 521         ServiceRestUtils.checkSuccess(restResponse); // serviceDetails_02
 522         // version 0.2
 523         // (Check-in)
 524
 525         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_03, sdncDesignerDetails,
 526                 LifeCycleStatesEnum.CHECKIN);
 527         ServiceRestUtils.checkSuccess(restResponse);
 528         String service3_UniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(restResponse);
 529         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_03, sdncDesignerDetails,
 530                 LifeCycleStatesEnum.CHECKOUT);
 531         ServiceRestUtils.checkSuccess(restResponse); // serviceDetails_03
 532         // version 0.2
 533         // (Check-out)
 534
 535         RestResponse getServicesLatestVersion = ServiceRestUtils.getServiceLatestVersionList(sdncDesignerDetails);
 536         ServiceRestUtils.checkSuccess(getServicesLatestVersion);
 537         List<Service> serviceList = restResponseToResourceObjectList(getServicesLatestVersion);
 538         assertTrue(serviceList.size() == 3);
 539         Service servcieFromList = getResourceObjectFromResourceListByUid(serviceList, service1_UniqueIdFromResponse);
 540         assertTrue(servcieFromList.getVersion().equals("2.0"));
 541         servcieFromList = getResourceObjectFromResourceListByUid(serviceList, serviceDetails_02.getUniqueId());
 542         assertTrue(servcieFromList.getVersion().equals("0.2"));
 543         servcieFromList = getResourceObjectFromResourceListByUid(serviceList, service3_UniqueIdFromResponse);
 544         assertTrue(servcieFromList.getVersion().equals("0.1"));
 545     }
 546
 547     ///////////////////////////////////////////////////////////////
 548     private RestResponse certifyService(ServiceReqDetails serviceDetails) throws Exception {
 549         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails,
 550                 LifeCycleStatesEnum.CHECKIN);
 551         ServiceRestUtils.checkSuccess(restResponse);
 552         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails,
 553                 LifeCycleStatesEnum.CHECKOUT);
 554         ServiceRestUtils.checkSuccess(restResponse);
 555         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails,
 556                 LifeCycleStatesEnum.CHECKIN);
 557         ServiceRestUtils.checkSuccess(restResponse);
 558         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails,
 559                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 560         ServiceRestUtils.checkSuccess(restResponse);
 561         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncTesterDetails,
 562                 LifeCycleStatesEnum.STARTCERTIFICATION);
 563         ServiceRestUtils.checkSuccess(restResponse);
 564         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncTesterDetails,
 565                 LifeCycleStatesEnum.CERTIFY);
 566         ServiceRestUtils.checkSuccess(restResponse);
 567         return restResponse;
 568     }
 569
 570     protected List<Service> restResponseToResourceObjectList(RestResponse restResponse) {
 571         JsonElement jelement = new JsonParser().parse(restResponse.getResponse());
 572         JsonArray jsonArray = jelement.getAsJsonArray();
 573         List<Service> restResponseArray = new ArrayList<>();
 574         Service service = null;
 575         for (int i = 0; i < jsonArray.size(); i++) {
 576             String serviceString = (String) jsonArray.get(i).toString();
 577             service = ResponseParser.convertServiceResponseToJavaObject(serviceString);
 578             restResponseArray.add(service);
 579         }
 580         return restResponseArray;
 581     }
 582
 583     protected Service getResourceObjectFromResourceListByUid(List<Service> serviceList, String uid) {
 584         if (serviceList != null && serviceList.size() > 0) {
 585             for (Service service : serviceList) {
 586                 if (service.getUniqueId().equals(uid))
 587                     return service;
 588             }
 589         } else
 590             return null;
 591         return null;
 592     }
 593
 594     private RestResponse changeResourceStateToCertified(ResourceReqDetails resourceDetails) throws Exception {
 595         RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails,
 596                 LifeCycleStatesEnum.CHECKIN);
 597         ResourceRestUtils.checkSuccess(restResponse);
 598                 /*restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails,
 599                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 600                 if (restResponse.getErrorCode() == 200) {
 601                         restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterDetails,
 602                                         LifeCycleStatesEnum.STARTCERTIFICATION);
 603                 } else
 604                         return restResponse;
 605                 if (restResponse.getErrorCode() == 200) {*/
 606         restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterDetails, LifeCycleStatesEnum.CERTIFY);
 607         if (restResponse.getErrorCode() == 200) {
 608             String newVersion = ResponseParser.getVersionFromResponse(restResponse);
 609             resourceDetails.setVersion(newVersion);
 610             resourceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
 611             resourceDetails.setLastUpdaterUserId(sdncTesterDetails.getUserId());
 612             resourceDetails.setLastUpdaterFullName(sdncTesterDetails.getFullName());
 613             String uniqueIdFromRresponse = ResponseParser.getValueFromJsonResponse(restResponse.getResponse(),
 614                     "uniqueId");
 615             resourceDetails.setUniqueId(uniqueIdFromRresponse);
 616         }
 617         return restResponse;
 618     }
 619
 620     // private void certifyVf(ResourceReqDetails resource) throws Exception {
 621     // RestResponse createAtomicResourceInstance =
 622     // createAtomicInstanceForVFDuringSetup(resource, resourceDetailsVFC_01,
 623     // sdncDesignerDetails);
 624     // ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 625     // createAtomicResourceInstance =
 626     // createAtomicInstanceForVFDuringSetup(resource, resourceDetailsCP_01,
 627     // sdncDesignerDetails);
 628     // ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 629     // createAtomicResourceInstance =
 630     // createAtomicInstanceForVFDuringSetup(resource, resourceDetailsVL_01,
 631     // sdncDesignerDetails);
 632     // ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 633     // //createVFInstanceDuringSetup(service, resource, sdncDesignerDetails);
 634     // RestResponse response =
 635     // ArtifactRestUtils.addInformationalArtifactToResource(heatArtifactDetails,
 636     // sdncDesignerDetails, resource.getUniqueId());
 637     // ResourceRestUtils.checkSuccess(response);
 638     // RestResponse changeResourceStateToCertified =
 639     // changeResourceStateToCertified(resource);
 640     // ResourceRestUtils.checkSuccess(changeResourceStateToCertified);
 641     // }
 642
 643     private void certifyVf(ResourceReqDetails resource) throws Exception {
 644         RestResponse createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, resourceDetailsCP_01,
 645                 sdncDesignerDetails);
 646         ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 647         String cpCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
 648
 649         createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, resourceDetailsVFC_01,
 650                 sdncDesignerDetails);
 651         ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 652         String computeCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
 653
 654         createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, resourceDetailsVL_01,
 655                 sdncDesignerDetails);
 656         ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 657         String vlCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
 658
 659         // Fixing Vl/Cp req/cap
 660         ComponentTypeEnum containerCompType = ComponentTypeEnum.RESOURCE;
 661         User user = sdncDesignerDetails;
 662         fulfillCpRequirement(resource, cpCompInstId, computeCompInstId, computeCompInstId, user, containerCompType);
 663         consumeVlCapability(resource, cpCompInstId, vlCompInstId, cpCompInstId, user, containerCompType);
 664
 665         RestResponse response = ArtifactRestUtils.addInformationalArtifactToResource(heatArtifactDetails,
 666                 sdncDesignerDetails, resource.getUniqueId());
 667         ResourceRestUtils.checkSuccess(response);
 668         RestResponse changeResourceStateToCertified = changeResourceStateToCertified(resource);
 669         ResourceRestUtils.checkSuccess(changeResourceStateToCertified);
 670     }
 671
 672 }