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