test-apis-ci/src/main/java/org/openecomp/sdc/externalApis/AssetLifeCycle.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.externalApis;
  22
  23 import com.aventstack.extentreports.Status;
  24 import com.google.gson.Gson;
  25 import fj.data.Either;
  26 import org.json.simple.parser.JSONParser;
  27 import org.junit.Rule;
  28 import org.junit.rules.TestName;
  29 import org.openecomp.sdc.be.dao.api.ActionStatus;
  30 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
  31 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  32 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  33 import org.openecomp.sdc.be.model.*;
  34 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  35 import org.openecomp.sdc.ci.tests.config.Config;
  36 import org.openecomp.sdc.ci.tests.datatypes.*;
  37 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
  38 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  39 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  40 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  41 import org.openecomp.sdc.ci.tests.utils.rest.*;
  42 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45 import org.testng.Assert;
  46 import org.testng.SkipException;
  47 import org.testng.annotations.DataProvider;
  48 import org.testng.annotations.Test;
  49
  50 import java.io.FileNotFoundException;
  51
  52 public class AssetLifeCycle extends ComponentBaseTest {
  53         private static Logger log = LoggerFactory.getLogger(CRUDExternalAPI.class.getName());
  54         protected static final String UPLOAD_ARTIFACT_PAYLOAD = "UHVUVFktVXNlci1LZXktRmlsZS0yOiBzc2gtcnNhDQpFbmNyeXB0aW9uOiBhZXMyNTYtY2JjDQpDb21tZW5wOA0K";
  55         protected static final String UPLOAD_ARTIFACT_NAME = "TLV_prv.ppk";
  56
  57         protected Config config = Config.instance();
  58         protected String contentTypeHeaderData = "application/json";
  59         protected String acceptHeaderDate = "application/json";
  60         protected static User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  61
  62         protected Gson gson = new Gson();
  63         protected JSONParser jsonParser = new JSONParser();
  64
  65
  66         protected String serviceVersion;
  67         protected ResourceReqDetails resourceDetails;
  68         protected User sdncUserDetails;
  69         protected ServiceReqDetails serviceDetails;
  70
  71         public static final int STATUS_CODE_SUCCESS = getResponseCodeByAction(ActionStatus.OK);
  72         public static final int STATUS_CODE_CREATED = getResponseCodeByAction(ActionStatus.CREATED);
  73         public static final int STATUS_CODE_NOT_FOUND = getResponseCodeByAction(ActionStatus.RESOURCE_NOT_FOUND);
  74         public static final int STATUS_CODE_INVALID_CONTENT = getResponseCodeByAction(ActionStatus.INVALID_CONTENT);
  75         public static final int STATUS_CODE_MISSING_INFORMATION = getResponseCodeByAction(ActionStatus.MISSING_INFORMATION);
  76         public static final int STATUS_CODE_ALREADY_EXISTS = getResponseCodeByAction(ActionStatus.RESOURCE_ALREADY_EXISTS);
  77         public static final Integer RESTRICTED_OPERATION = getResponseCodeByAction(ActionStatus.RESTRICTED_OPERATION);
  78         public static final int COMPONENT_IN_CHECKOUT_STATE = getResponseCodeByAction(ActionStatus.COMPONENT_IN_CHECKOUT_STATE);
  79         public static final int COMPONENT_ALREADY_CHECKED_IN = getResponseCodeByAction(ActionStatus.COMPONENT_ALREADY_CHECKED_IN);
  80         public static final int COMPONENT_NOT_READY_FOR_CERTIFICATION = getResponseCodeByAction(ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION);
  81         public static final int COMPONENT_SENT_FOR_CERTIFICATION = getResponseCodeByAction(ActionStatus.COMPONENT_SENT_FOR_CERTIFICATION);
  82         public static final int COMPONENT_IN_CERT_IN_PROGRESS_STATE = getResponseCodeByAction(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE);
  83         public static final int COMPONENT_ALREADY_CERTIFIED = getResponseCodeByAction(ActionStatus.COMPONENT_ALREADY_CERTIFIED);
  84
  85
  86
  87         public static int getResponseCodeByAction(ActionStatus actionStatus ){
  88                 ErrorInfo errorInfo;
  89                 try {
  90                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(actionStatus.name());
  91                         return errorInfo.getCode();
  92                 } catch (FileNotFoundException e) {
  93                         e.printStackTrace();
  94                 }
  95                 return 100500;
  96         }
  97
  98         @Rule
  99         public static TestName name = new TestName();
 100
 101         public AssetLifeCycle() {
 102                 super(name, AssetLifeCycle.class.getName());
 103
 104         }
 105
 106
 107         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 108         @Test
 109         public void createResourceCheckInThenCheckOut() throws Exception {
 110                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 111                 ResourceExternalReqDetails defaultResource = ElementFactory.getDefaultResourceByType("ci", ResourceCategoryEnum.TEMPLATE_MONITORING_TEMPLATE, defaultUser.getUserId(), ResourceTypeEnum.VF.toString());
 112
 113                 RestResponse restResponse = ResourceRestUtilsExternalAPI.createResource(defaultResource, defaultUser);
 114                 defaultResource.setVersion(String.format("%.1f",0.1));
 115                 ResourceAssetStructure parsedCreatedResponse = gson.fromJson(restResponse.getResponse(), ResourceAssetStructure.class);
 116
 117                 restResponse = LifecycleRestUtils.checkInResource(parsedCreatedResponse.getUuid(), defaultUser);
 118                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check in.");
 119
 120                 Component resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, defaultResource.getName(), defaultResource.getVersion());
 121                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKIN.getComponentState().toString(), "Life cycle state not changed.");
 122
 123                 /*// auditing verification
 124                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 125                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 126                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, parsedCreatedResponse.getName());
 127                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.RESOURCES);
 128                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);*/
 129
 130                 restResponse = LifecycleRestUtils.checkOutResource(parsedCreatedResponse.getUuid(), defaultUser);
 131                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check out.");
 132
 133                 resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, defaultResource.getName(), String.format("%.1f", Double.parseDouble(defaultResource.getVersion()) + 0.1));
 134                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKOUT.getComponentState().toString(), "Life cycle state not changed.");
 135
 136                 /*// auditing verification
 137                 body = new HashMap<>();
 138                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, parsedCreatedResponse.getName());
 139                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 140                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.RESOURCES);
 141                 expectedResourceAuditJavaObject.setCurrVersion("0.2");
 142                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 143                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 144                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);*/
 145
 146         }
 147
 148         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 149         @Test
 150         public void createServiceCheckInThenCheckOut() throws Exception {
 151                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 152
 153                 Component resourceDetails = null;
 154                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 155                 resourceDetails = createdComponent.left().value();
 156
 157                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), defaultUser);
 158                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check in.");
 159
 160                 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, resourceDetails.getName(), resourceDetails.getVersion());
 161                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKIN.getComponentState().toString(), "Life cycle state not changed.");
 162
 163                 /*// auditing verification
 164                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 165                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 166                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 167                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.SERVICES);
 168                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);*/
 169
 170                 restResponse = LifecycleRestUtils.checkOutService(resourceDetails.getUUID(), defaultUser);
 171                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check out.");
 172
 173                 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, resourceDetails.getName(), String.format("%.1f", Double.parseDouble(resourceDetails.getVersion()) + 0.1));
 174                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKOUT.getComponentState().toString(), "Life cycle state not changed.");
 175
 176                 /*// auditing verification
 177                 body = new HashMap<>();
 178                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 179                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 180                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.SERVICES);
 181                 expectedResourceAuditJavaObject.setCurrVersion("0.2");
 182                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 183                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 184                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);*/
 185         }
 186
 187         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 188
 189         @DataProvider(name="invalidAssetUUID")
 190         public static Object[][] dataProviderInvalidAssetUUID() {
 191                 return new Object[][] {
 192                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CHECKIN},
 193                         {AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CHECKIN},
 194
 195                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CHECKOUT},
 196                         {AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CHECKOUT},
 197
 198                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CERTIFICATIONREQUEST},
 199                         /*{AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CERTIFICATIONREQUEST},*/
 200
 201                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.STARTCERTIFICATION},
 202                         /*{AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.STARTCERTIFICATION},*/
 203                         };
 204         }
 205
 206         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 207         @Test(dataProvider="invalidAssetUUID")
 208         public void invalidAssetUUID(AssetTypeEnum assetTypeEnum, LifeCycleStatesEnum lifeCycleStatesEnum) throws Exception {
 209                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 210                 String assetUUID = "InvalidAssetUUID";
 211                 ErrorInfo errorInfo = null;
 212
 213                 RestResponse restResponse = null;
 214                 if(assetTypeEnum.equals(AssetTypeEnum.SERVICES)) {
 215
 216                         if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKIN)) {
 217                                 restResponse = LifecycleRestUtils.checkInService(assetUUID, defaultUser);
 218                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKOUT)) {
 219                                 restResponse = LifecycleRestUtils.checkOutService(assetUUID, defaultUser);
 220                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 221                                 restResponse = LifecycleRestUtils.certificationRequestService(assetUUID, defaultUser);
 222                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 223                                 restResponse = LifecycleRestUtils.startTestingService(assetUUID, defaultUser);
 224                         }
 225
 226                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.SERVICE_NOT_FOUND.name());
 227                 } else {
 228
 229                         if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKIN)) {
 230                                 restResponse = LifecycleRestUtils.checkInResource(assetUUID, defaultUser);
 231                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKOUT)) {
 232                                 restResponse = LifecycleRestUtils.checkOutResource(assetUUID, defaultUser);
 233                         /*} else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 234                                 restResponse = LifecycleRestUtils.certificationRequestResource(assetUUID, defaultUser);
 235                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 236                                 restResponse = LifecycleRestUtils.startTestingResource(assetUUID, defaultUser);*/
 237                         }
 238
 239                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
 240
 241                 }
 242                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_NOT_FOUND, "Asset found.");
 243
 244         }
 245
 246         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 247
 248         @DataProvider(name="invalidUserCheckinForCheckedOutService")
 249         public static Object[][] dataProviderInvalidUserCheckinForCheckedOutService() {
 250                 return new Object[][] {
 251                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 252                         // TODO: remove comment after talk with renana if it is defect or not
 253 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 254                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 255                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 256                         /*due to those roles are not exists in the system               {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 257                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 258                         };
 259         }
 260
 261         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 262         @Test(dataProvider="invalidUserCheckinForCheckedOutService")
 263         public void invalidUserCheckinForCheckedOutService(User defaultUser) throws Exception {
 264                 Component resourceDetails = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 265                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), defaultUser);
 266                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 267
 268         }
 269
 270         @DataProvider(name="invalidUserCheckinForCheckedInService")
 271         public static Object[][] dataProviderInvalidUserCheckinForCheckedInService() {
 272                 return new Object[][] {
 273                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 274                         // TODO: remove comment after talk with renana if it is defect or not
 275 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 276                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 277                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 278                         /*due to those roles are not exists in the system                                       {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 279                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 280                         };
 281         }
 282
 283         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 284         @Test(dataProvider="invalidUserCheckinForCheckedInService")
 285         public void invalidUserCheckinForCheckedInService(User defaultUser) throws Exception {
 286                 Component resourceDetails = null;
 287                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 288                 resourceDetails = createdComponent.left().value();
 289                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 290                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), defaultUser);
 291                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 292
 293         }
 294
 295         @DataProvider(name="invalidUserCheckoutForCheckedOutService")
 296         public static Object[][] dataProviderInvalidUserCheckoutForCheckedOutService() {
 297                 return new Object[][] {
 298                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 299                         // TODO: remove comment after talk with renana if it is defect or not
 300 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 301                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 302                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 303                         /*due to those roles are not exists in the system               {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 304                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 305                         };
 306         }
 307
 308         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 309         @Test(dataProvider="invalidUserCheckoutForCheckedOutService")
 310         public void invalidUserCheckoutForCheckedOutService(User defaultUser) throws Exception {
 311
 312                 Component resourceDetails = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 313                 RestResponse restResponse = LifecycleRestUtils.checkOutService(resourceDetails.getUUID(), defaultUser);
 314                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 315
 316         }
 317
 318         @DataProvider(name="invalidUserCheckoutForCheckedInService")
 319         public static Object[][] dataProviderInvalidUserCheckoutForCheckedInService() {
 320                 return new Object[][] {
 321                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 322                         // TODO: remove comment after talk with renana if it is defect or not
 323 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 324                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 325                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 326                         /*due to those roles are not exists in the system               {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 327                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 328                         };
 329         }
 330
 331         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 332         @Test(dataProvider="invalidUserCheckoutForCheckedInService")
 333         public void invalidUserCheckoutForCheckedInService(User defaultUser) throws Exception {
 334                 Component resourceDetails = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 335                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 336                 RestResponse restResponse = LifecycleRestUtils.checkOutService(resourceDetails.getUUID(), defaultUser);
 337                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 338
 339         }
 340
 341         @DataProvider(name="invalidUserCheckinForCheckedOutResource")
 342         public static Object[][] dataProviderInvalidUserCheckinForCheckedOutResource() {
 343                 return new Object[][] {
 344                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 345                         // TODO: remove comment after talk with renana if it is defect or not
 346 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 347                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 348                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 349         /*due to those roles are not exists in the system               {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 350                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 351                         };
 352         }
 353
 354         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 355         @Test(dataProvider="invalidUserCheckinForCheckedOutResource")
 356         public void invalidUserCheckinForCheckedOutResource(User defaultUser) throws Exception {
 357
 358                 Component resourceDetails = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true).left().value();
 359                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), defaultUser);
 360                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 361
 362         }
 363
 364         @DataProvider(name="invalidUserCheckinForCheckedInResource")
 365         public static Object[][] dataProviderInvalidUserCheckinForCheckedInResource() {
 366                 return new Object[][] {
 367                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 368                         // TODO: remove comment after talk with renana if it is defect or not
 369 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 370                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 371                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 372                         /*due to those roles are not exists in the system               {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 373                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 374                         };
 375         }
 376
 377         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 378         @Test(dataProvider="invalidUserCheckinForCheckedInResource")
 379         public void invalidUserCheckinForCheckedInResource(User defaultUser) throws Exception {
 380                 Component resourceDetails = null;
 381                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 382                 resourceDetails = createdComponent.left().value();
 383                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 384
 385                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), defaultUser);
 386                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 387         }
 388
 389         @DataProvider(name="invalidUserCheckoutForCheckedOutResource")
 390         public static Object[][] dataProviderInvalidUserCheckoutForCheckedOutResource() {
 391                 return new Object[][] {
 392                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 393                         // TODO: remove comment after talk with renana if it is defect or not
 394 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 395                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 396                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 397                         /*due to those roles are not exists in the system               {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 398                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 399                         };
 400         }
 401
 402         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 403         @Test(dataProvider="invalidUserCheckoutForCheckedOutResource")
 404         public void invalidUserCheckoutForCheckedOutResource(User defaultUser) throws Exception {
 405
 406                 Component resourceDetails = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true).left().value();
 407                 RestResponse restResponse = LifecycleRestUtils.checkOutResource(resourceDetails.getUUID(), defaultUser);
 408                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 409
 410         }
 411
 412         @DataProvider(name="invalidUserCheckoutForCheckedInResource")
 413         public static Object[][] dataProviderInvalidUserCheckoutForCheckedInResource() {
 414                 return new Object[][] {
 415                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 416                         // TODO: remove comment after talk with renana if it is defect or not
 417 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 418                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 419                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 420                         /*due to those roles are not exists in the system               {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 421                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},*/
 422                         };
 423         }
 424
 425         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 426         @Test(dataProvider="invalidUserCheckoutForCheckedInResource")
 427         public void invalidUserCheckoutForCheckedInResource(User defaultUser) throws Exception {
 428
 429                 Component resourceDetails = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true).left().value();
 430                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 431
 432                 RestResponse restResponse = LifecycleRestUtils.checkOutResource(resourceDetails.getUUID(), defaultUser);
 433                 Assert.assertEquals(restResponse.getErrorCode(), RESTRICTED_OPERATION, "Expected for restricted operation.");
 434
 435         }
 436
 437         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 438         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 439         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 440
 441
 442
 443
 444         @DataProvider(name="invalidStatesForService")
 445         public static Object[][] dataProviderInvalidStatesForService() {
 446                 return new Object[][] {
 447                         {LifeCycleStatesEnum.CHECKIN, LifeCycleStatesEnum.CHECKIN, COMPONENT_ALREADY_CHECKED_IN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, "409", ActionStatus.COMPONENT_ALREADY_CHECKED_IN, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 448                         {LifeCycleStatesEnum.CHECKIN, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 449                         {LifeCycleStatesEnum.CHECKIN, LifeCycleStatesEnum.CERTIFY, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 450
 451                         {LifeCycleStatesEnum.CHECKOUT, LifeCycleStatesEnum.CHECKOUT, COMPONENT_IN_CHECKOUT_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, "403", ActionStatus.COMPONENT_IN_CHECKOUT_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 452                         {LifeCycleStatesEnum.CHECKOUT, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 453                         {LifeCycleStatesEnum.CHECKOUT, LifeCycleStatesEnum.CERTIFY, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 454
 455                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_SENT_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, "403", ActionStatus.COMPONENT_SENT_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 456                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, LifeCycleStatesEnum.CERTIFY, RESTRICTED_OPERATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, "409", ActionStatus.RESTRICTED_OPERATION, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 457
 458                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.CHECKIN, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 459                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.CHECKOUT, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 460                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 461                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 462
 463                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CHECKIN, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 464                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 465                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 466                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CERTIFY, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 467                 };
 468         }
 469
 470         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 471         @Test(dataProvider="invalidStatesForService")
 472         public void invalidStatesForService(LifeCycleStatesEnum initState, LifeCycleStatesEnum targetState, int errorCode,
 473                         LifecycleStateEnum preState, LifecycleStateEnum currState, String status,
 474                         ActionStatus actionStatus, User user, User operationUser) throws Exception {
 475
 476                 if(initState.equals(LifeCycleStatesEnum.STARTCERTIFICATION) && targetState.equals(LifeCycleStatesEnum.CHECKIN)){
 477                         throw new SkipException("Open bug DE270217 or TDP number: 154592");
 478                 }
 479
 480                 getExtendTest().log(Status.INFO, String.format("initState: %s, targetState: %s, errorCode: %s,"
 481                                 + " preState: %s, currState: %s, status: %s, actionStatus: %s, user: %s, operationUser: %s", initState, targetState, errorCode, preState,
 482                                 currState, status, actionStatus, user, operationUser));
 483
 484
 485                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 486                 Component service = createdComponent.left().value();
 487
 488                 service = AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, initState, true).getLeft();
 489
 490                 RestResponse restResponse = null;
 491
 492                 if(targetState.equals(LifeCycleStatesEnum.CHECKOUT)) {
 493                         restResponse = LifecycleRestUtils.checkOutService(service.getUUID(), user);
 494                 } else if(targetState.equals(LifeCycleStatesEnum.CHECKIN)) {
 495                         restResponse = LifecycleRestUtils.checkInService(service.getUUID(), user);
 496                 } else if(targetState.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 497                         restResponse = LifecycleRestUtils.certificationRequestService(service.getUUID(), user);
 498                 } else if(targetState.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 499                         restResponse = LifecycleRestUtils.startTestingService(service.getUUID(), user);
 500                 } else if(targetState.equals(LifeCycleStatesEnum.CERTIFY)) {
 501                         restResponse = LifecycleRestUtils.certifyService(service.getUUID(), user);
 502                 }
 503
 504                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)errorCode, "Expected that response code will be equal.");
 505
 506         }
 507
 508         @DataProvider(name="invalidStatesForResource")
 509         public static Object[][] dataProviderInvalidStatesForResource() {
 510                 return new Object[][] {
 511                         {LifeCycleStatesEnum.CHECKIN, LifeCycleStatesEnum.CHECKIN, COMPONENT_ALREADY_CHECKED_IN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, "409", ActionStatus.COMPONENT_ALREADY_CHECKED_IN, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 512                 /*      {LifeCycleStatesEnum.CHECKIN, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},*/
 513                         {LifeCycleStatesEnum.CHECKIN, LifeCycleStatesEnum.CERTIFY, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 514
 515                         {LifeCycleStatesEnum.CHECKOUT, LifeCycleStatesEnum.CHECKOUT, COMPONENT_IN_CHECKOUT_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, "403", ActionStatus.COMPONENT_IN_CHECKOUT_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 516                 /*      {LifeCycleStatesEnum.CHECKOUT, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},*/
 517                         {LifeCycleStatesEnum.CHECKOUT, LifeCycleStatesEnum.CERTIFY, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 518
 519                         /*{LifeCycleStatesEnum.CERTIFICATIONREQUEST, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_SENT_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, "403", ActionStatus.COMPONENT_SENT_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 520                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, LifeCycleStatesEnum.CERTIFY, RESTRICTED_OPERATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, "409", ActionStatus.RESTRICTED_OPERATION, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 521
 522                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.CHECKIN, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 523                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.CHECKOUT, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 524                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 525                         {LifeCycleStatesEnum.STARTCERTIFICATION, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_IN_CERT_IN_PROGRESS_STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, "403", ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},*/
 526
 527                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CHECKIN, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 528                         /*{LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 529                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},*/
 530                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CERTIFY, COMPONENT_NOT_READY_FOR_CERTIFICATION, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 531                 };
 532         }
 533
 534         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 535         @Test(dataProvider="invalidStatesForResource")
 536         public void invalidStatesForResource(LifeCycleStatesEnum initState, LifeCycleStatesEnum targetState, int errorCode,
 537                         LifecycleStateEnum preState, LifecycleStateEnum currState, String status,
 538                         ActionStatus actionStatus, User user, User operationUser) throws Exception {
 539
 540                 getExtendTest().log(Status.INFO, String.format("initState: %s, targetState: %s, errorCode: %s,"
 541                                 + " preState: %s, currState: %s, status: %s, actionStatus: %s, user: %s, operationUser: %s", initState, targetState, errorCode, preState,
 542                                 currState, status, actionStatus, user, operationUser));
 543
 544                 if(initState.equals(LifeCycleStatesEnum.STARTCERTIFICATION) && targetState.equals(LifeCycleStatesEnum.CHECKIN)){
 545                         throw new SkipException("Open bug DE270217 or TDP number: 154592");
 546                 }
 547
 548                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 549                 Component resourceDetails = createdComponent.left().value();
 550
 551                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, initState, true).getLeft();
 552
 553                 RestResponse restResponse = null;
 554
 555                 if(targetState.equals(LifeCycleStatesEnum.CHECKOUT)) {
 556                         restResponse = LifecycleRestUtils.checkOutResource(resourceDetails.getUUID(), user);
 557                 } else if(targetState.equals(LifeCycleStatesEnum.CHECKIN)) {
 558                         restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), user);
 559                 /*} else if(targetState.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 560                         restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), user);
 561                 } else if(targetState.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 562                         restResponse = LifecycleRestUtils.startTestingResource(resourceDetails.getUUID(), user);*/
 563                 } else if(targetState.equals(LifeCycleStatesEnum.CERTIFY)) {
 564                         restResponse = LifecycleRestUtils.certifyResource(resourceDetails.getUUID(), user);
 565                 }
 566
 567                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)errorCode, "Expected that response code will be equal.");
 568
 569         }
 570
 571
 572
 573
 574         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 575         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 576         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 577
 578 /*      // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 579         @Test
 580         public void BasicFlowForResourceSubmitForTestingStartTesting() throws Exception {
 581                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 582                 Component resourceDetails = createdComponent.left().value();
 583                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 584
 585                 // Certification request
 586                 restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 587         }*/
 588
 589         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 590         @Test
 591         public void BasicFlowForServiceSubmitForTestingStartTesting() throws Exception {
 592                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 593                 Component resourceDetails = createdComponent.left().value();
 594                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 595
 596                 // Certification request
 597                 restResponse = LifecycleRestUtils.certificationRequestService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 598
 599                 // Start testing
 600                 restResponse = LifecycleRestUtils.startTestingService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 601
 602         }
 603
 604         /*// US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 605         @Test
 606         public void specialCaseInvalidFlowForVfcmtSubmitForTesting() throws Exception {
 607                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VFCMT, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 608                 Component resourceDetails = createdComponent.left().value();
 609                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 610
 611                 // Certification request
 612                 restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 613         }*/
 614
 615         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 616         @Test
 617         public void specialCaseInvalidFlowForVfcmtStartTesting() throws Exception {
 618                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VFCMT, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 619                 Component resourceDetails = createdComponent.left().value();
 620                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 621
 622                 // Certification request
 623                 restResponse = LifecycleRestUtils.startTestingResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 624
 625         }
 626
 627
 628
 629         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 630         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 631         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 632
 633
 634
 635
 636         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 637         @Test
 638         public void BasicFlowForResourceCertify() throws Exception {
 639                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 640                 Component resourceDetails = createdComponent.left().value();
 641                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 642
 643                 /*// Certification request
 644                 restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 645
 646                 // Start testing
 647                 restResponse = LifecycleRestUtils.startTestingResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));*/
 648
 649                 // Certify
 650                 restResponse = LifecycleRestUtils.certifyResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 651         }
 652
 653         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 654         @Test
 655         public void BasicFlowForServiceCertify() throws Exception {
 656                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 657                 Component resourceDetails = createdComponent.left().value();
 658                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 659
 660                 // Certification request
 661                 restResponse = LifecycleRestUtils.certificationRequestService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 662
 663                 // Start testing
 664                 restResponse = LifecycleRestUtils.startTestingService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 665
 666                 // Certify
 667                 restResponse = LifecycleRestUtils.certifyService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 668
 669         }
 670
 671
 672
 673
 674
 675
 676
 677
 678         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 679         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 680         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 681
 682         @Test
 683         public void theFlow() throws Exception {
 684                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 685                 ResourceExternalReqDetails defaultResource = ElementFactory.getDefaultResourceByType("ci", ResourceCategoryEnum.TEMPLATE_MONITORING_TEMPLATE, defaultUser.getUserId(), ResourceTypeEnum.VFCMT.toString());
 686
 687                 // 1. Create VFCMT.
 688                 RestResponse restResponse = ResourceRestUtilsExternalAPI.createResource(defaultResource, defaultUser);
 689                 BaseRestUtils.checkCreateResponse(restResponse);
 690                 ResourceAssetStructure parsedCreatedResponse = gson.fromJson(restResponse.getResponse(), ResourceAssetStructure.class);
 691
 692                 // 2. Using search external API with resourceType=VFCMT to retrieve VFCMT.
 693                 restResponse = ResourceRestUtils.getResourceListFilterByCriteria(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), SearchCriteriaEnum.RESOURCE_TYPE.getValue(), ResourceTypeEnum.VFCMT.toString());
 694                 BaseRestUtils.checkSuccess(restResponse);
 695                 ResourceAssetStructure dataOutOfSearchResponseForResourceName = ResponseParser.getDataOutOfSearchExternalAPIResponseForResourceName(restResponse.getResponse(), parsedCreatedResponse.getName());
 696                 Assert.assertEquals(parsedCreatedResponse.getUuid(), dataOutOfSearchResponseForResourceName.getUuid(), "Created resourceUUID not equal to search retrive resourceUUID.");
 697
 698                 // 3. Use getSpecificMetadata external API to receive full information of the VFCMT.
 699                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES, dataOutOfSearchResponseForResourceName.getUuid());
 700                 BaseRestUtils.checkSuccess(assetResponse);
 701                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
 702                 Assert.assertEquals(resourceAssetMetadata.getUuid(), parsedCreatedResponse.getUuid(), "Created resourceUUID not equal to getSpecificMetadata resourceUUID.");
 703
 704                 // 4. Upload artifact via upload artifact external API.
 705                 Component initComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), parsedCreatedResponse.getVersion());
 706                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", "OTHER", true, false);
 707                 RestResponse uploadArtifactRestResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(initComponentVersion, defaultUser, artifactReqDetails);
 708                 BaseRestUtils.checkSuccess(uploadArtifactRestResponse);
 709
 710                 ArtifactDefinition responseArtifact = ResponseParser.convertArtifactDefinitionResponseToJavaObject(uploadArtifactRestResponse.getResponse());
 711 //              ArtifactDefinition responseArtifact = ArtifactRestUtils.getArtifactDataFromJson(uploadArtifactRestResponse.getResponse());
 712                 initComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), parsedCreatedResponse.getVersion());
 713
 714                 // 5. Update artifact via external API.
 715                 CRUDExternalAPI crudExternalAPI = new CRUDExternalAPI();
 716                 crudExternalAPI.updateArtifactOnAssetViaExternalAPI(initComponentVersion, ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, "OTHER");
 717
 718
 719                 // 6. Use external API to checkin the VFCMT.
 720                 RestResponse checkInRestResponse = LifecycleRestUtils.checkInResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 721                 BaseRestUtils.checkCreateResponse(checkInRestResponse);
 722                 parsedCreatedResponse = gson.fromJson(checkInRestResponse.getResponse(), ResourceAssetStructure.class);
 723                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "0.1", "Expect that version will not change.");
 724                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
 725                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
 726
 727                 // 7. Then checkout the VFCMT via external API.
 728                 RestResponse checkOutRestResponse = LifecycleRestUtils.checkOutResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 729                 BaseRestUtils.checkCreateResponse(checkOutRestResponse);
 730                 parsedCreatedResponse = gson.fromJson(checkOutRestResponse.getResponse(), ResourceAssetStructure.class);
 731                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "0.2", "Expect that version will change to 0.2.");
 732                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
 733                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
 734
 735                 // 8. The minor version must be incremented, the invariantUUID, and UUID must stay the same, the uniqueId should be changed, the artifacts from first version exists on the new version.
 736                 Component newComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), String.format("%.1f", Double.parseDouble(parsedCreatedResponse.getVersion())));
 737                 Assert.assertEquals(newComponentVersion.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
 738                 Assert.assertEquals(newComponentVersion.getUUID(), initComponentVersion.getUUID(), "Expected that UUID will not change.");
 739                 Assert.assertNotEquals(newComponentVersion.getUniqueId(), initComponentVersion.getUniqueId(), "Expected that uniqueId will change.");
 740                 Assert.assertTrue(newComponentVersion.getDeploymentArtifacts().keySet().contains(responseArtifact.getArtifactLabel()), "Expected that artifact from first version exists on the new version.");
 741
 742                 // 9. The previous version remains untouched, the highest version flag on the first version is false, all information (metadata / artifacts) are the same on the first version.
 743                 initComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), String.format("%.1f", Double.parseDouble("0.1")));
 744                 Assert.assertEquals(initComponentVersion.isHighestVersion(), (Boolean)false, "Expected that highest version flag on first version is false.");
 745
 746                 // 10. Check in via external API.
 747                 checkInRestResponse = LifecycleRestUtils.checkInResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 748                 BaseRestUtils.checkCreateResponse(checkInRestResponse);
 749                 parsedCreatedResponse = gson.fromJson(checkInRestResponse.getResponse(), ResourceAssetStructure.class);
 750                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "0.2", "Expect that version will not change.");
 751                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
 752                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
 753
 754                 // 11. Certify via external API.
 755                 RestResponse certifyRestResponse = LifecycleRestUtils.certifyResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 756                 BaseRestUtils.checkCreateResponse(certifyRestResponse);
 757                 parsedCreatedResponse = gson.fromJson(certifyRestResponse.getResponse(), ResourceAssetStructure.class);
 758                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "1.0", "Expect that version will change to 1.0");
 759                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
 760                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
 761
 762                 // 12. Check out via external API.
 763                 checkOutRestResponse = LifecycleRestUtils.checkOutResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 764                 BaseRestUtils.checkCreateResponse(checkOutRestResponse);
 765                 parsedCreatedResponse = gson.fromJson(checkOutRestResponse.getResponse(), ResourceAssetStructure.class);
 766                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "1.1", "Expect that version will change to 1.1");
 767                 Assert.assertNotEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will change.");
 768                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
 769
 770         }
 771
 772 }