gerrit.onap Code Review - sdc.git/blob

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