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 static java.util.Arrays.asList;
  24
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import org.json.simple.parser.JSONParser;
  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.AssetTypeEnum;
  34 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  35 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  36 import org.openecomp.sdc.be.model.ArtifactDefinition;
  37 import org.openecomp.sdc.be.model.Component;
  38 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  39 import org.openecomp.sdc.be.model.Resource;
  40 import org.openecomp.sdc.be.model.Service;
  41 import org.openecomp.sdc.be.model.User;
  42 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  43 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  44 import org.openecomp.sdc.ci.tests.config.Config;
  45 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  46 import org.openecomp.sdc.ci.tests.datatypes.ResourceAssetStructure;
  47 import org.openecomp.sdc.ci.tests.datatypes.ResourceDetailedAssetStructure;
  48 import org.openecomp.sdc.ci.tests.datatypes.ResourceExternalReqDetails;
  49 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  50 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  51 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  52 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  55 import org.openecomp.sdc.ci.tests.datatypes.enums.SearchCriteriaEnum;
  56 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  57 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
  58 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  59 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  60 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  61 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  62 import org.openecomp.sdc.ci.tests.utils.rest.AssetRestUtils;
  63 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  64 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  65 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  66 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtilsExternalAPI;
  67 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  68 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  69 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  70 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  71 import org.slf4j.Logger;
  72 import org.slf4j.LoggerFactory;
  73 import org.testng.Assert;
  74 import org.testng.SkipException;
  75 import org.testng.annotations.DataProvider;
  76 import org.testng.annotations.Test;
  77
  78 import com.aventstack.extentreports.Status;
  79 import com.google.gson.Gson;
  80
  81 import fj.data.Either;
  82
  83 public class AssetLifeCycle extends ComponentBaseTest {
  84
  85         private static Logger log = LoggerFactory.getLogger(CRUDExternalAPI.class.getName());
  86         protected static final String UPLOAD_ARTIFACT_PAYLOAD = "UHVUVFktVXNlci1LZXktRmlsZS0yOiBzc2gtcnNhDQpFbmNyeXB0aW9uOiBhZXMyNTYtY2JjDQpDb21tZW5wOA0K";
  87         protected static final String UPLOAD_ARTIFACT_NAME = "TLV_prv.ppk";
  88
  89         protected Config config = Config.instance();
  90         protected String contentTypeHeaderData = "application/json";
  91         protected String acceptHeaderDate = "application/json";
  92         protected static User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  93
  94         protected Gson gson = new Gson();
  95         protected JSONParser jsonParser = new JSONParser();
  96
  97
  98         protected String serviceVersion;
  99         protected ResourceReqDetails resourceDetails;
 100         protected User sdncUserDetails;
 101         protected ServiceReqDetails serviceDetails;
 102
 103         public static final int STATUS_CODE_SUCCESS = 200;
 104         public static final int STATUS_CODE_CREATED = 201;
 105         public static final int STATUS_CODE_DELETE = 204;
 106         public static final int STATUS_CODE_NOT_FOUND = 404;
 107         public static final int STATUS_CODE_SUCCESS_NO_CONTENT = 204;
 108         public static final int STATUS_CODE_SUCCESS_DELETE = 204;
 109         public static final int STATUS_CODE_INVALID_CONTENT = 400;
 110         public static final int STATUS_CODE_MISSING_DATA = 400;
 111         public static final int STATUS_CODE_MISSING_INFORMATION = 403;
 112         public static final int STATUS_CODE_RESTRICTED_ACCESS = 403;
 113         public static final int STATUS_CODE_ALREADY_EXISTS = 409;
 114         public static final int STATUS_CODE_RESTRICTED_OPERATION = 409;
 115         public static final int STATUS_CODE_COMPONENT_NAME_EXCEEDS_LIMIT = 400;
 116         public static final int STATUS_CODE_MISSING_COMPONENT_NAME = 400;
 117         public static final int STATUS_CODE_UNSUPPORTED_ERROR = 400;
 118         public static final int STATUS_CODE_IMPORT_SUCCESS = 201;
 119         public static final int STATUS_CODE_UPDATE_SUCCESS = 200;
 120         public static final int RESTRICTED_OPERATION = 409;
 121         public static final int STATUS_CODE_GET_SUCCESS = 200;
 122         public static final int COMPONENT_IN_CHECKOUT_STATE = 403;
 123         public static final int COMPONENT_ALREADY_CHECKED_IN = 409;
 124         public static final int COMPONENT_NOT_READY_FOR_CERTIFICATION = 403;
 125         public static final int COMPONENT_SENT_FOR_CERTIFICATION = 403;
 126         public static final int COMPONENT_IN_CERT_IN_PROGRESS_STATE = 403;
 127         public static final int COMPONENT_ALREADY_CERTIFIED = 403;
 128
 129
 130
 131         @Rule
 132         public static TestName name = new TestName();
 133
 134         public AssetLifeCycle() {
 135                 super(name, AssetLifeCycle.class.getName());
 136
 137         }
 138
 139
 140         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 141         @Test
 142         public void createResourceCheckInThenCheckOut() throws Exception {
 143                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 144                 ResourceExternalReqDetails defaultResource = ElementFactory.getDefaultResourceByType("ci", ResourceCategoryEnum.TEMPLATE_MONITORING_TEMPLATE, defaultUser.getUserId(), ResourceTypeEnum.VF.toString());
 145
 146                 RestResponse restResponse = ResourceRestUtilsExternalAPI.createResource(defaultResource, defaultUser);
 147                 defaultResource.setVersion(String.format("%.1f",0.1));
 148                 ResourceAssetStructure parsedCreatedResponse = gson.fromJson(restResponse.getResponse(), ResourceAssetStructure.class);
 149
 150                 restResponse = LifecycleRestUtils.checkInResource(parsedCreatedResponse.getUuid(), defaultUser);
 151                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check in.");
 152
 153                 Component resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, defaultResource.getName(), defaultResource.getVersion());
 154                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKIN.getComponentState().toString(), "Life cycle state not changed.");
 155
 156                 // auditing verification
 157                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 158                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 159                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, parsedCreatedResponse.getName());
 160                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.RESOURCES);
 161                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 162
 163                 restResponse = LifecycleRestUtils.checkOutResource(parsedCreatedResponse.getUuid(), defaultUser);
 164                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check out.");
 165
 166                 resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, defaultResource.getName(), String.format("%.1f", Double.parseDouble(defaultResource.getVersion()) + 0.1));
 167                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKOUT.getComponentState().toString(), "Life cycle state not changed.");
 168
 169                 // auditing verification
 170                 body = new HashMap<>();
 171                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, parsedCreatedResponse.getName());
 172                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 173                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.RESOURCES);
 174                 expectedResourceAuditJavaObject.setCurrVersion("0.2");
 175                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 176                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 177                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 178
 179         }
 180
 181         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 182         @Test
 183         public void createServiceCheckInThenCheckOut() throws Exception {
 184                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 185
 186                 Component resourceDetails = null;
 187                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 188                 resourceDetails = createdComponent.left().value();
 189
 190                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), defaultUser);
 191                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check in.");
 192
 193                 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, resourceDetails.getName(), resourceDetails.getVersion());
 194                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKIN.getComponentState().toString(), "Life cycle state not changed.");
 195
 196                 // auditing verification
 197                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 198                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 199                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 200                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.SERVICES);
 201                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 202
 203                 restResponse = LifecycleRestUtils.checkOutService(resourceDetails.getUUID(), defaultUser);
 204                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_CREATED, "Fail to check out.");
 205
 206                 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, resourceDetails.getName(), String.format("%.1f", Double.parseDouble(resourceDetails.getVersion()) + 0.1));
 207                 Assert.assertEquals(resourceDetails.getLifecycleState().toString(), LifeCycleStatesEnum.CHECKOUT.getComponentState().toString(), "Life cycle state not changed.");
 208
 209                 // auditing verification
 210                 body = new HashMap<>();
 211                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 212                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 213                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.SERVICES);
 214                 expectedResourceAuditJavaObject.setCurrVersion("0.2");
 215                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 216                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 217                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 218         }
 219
 220         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 221
 222         @DataProvider(name="invalidAssetUUID")
 223         public static Object[][] dataProviderInvalidAssetUUID() {
 224                 return new Object[][] {
 225                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CHECKIN},
 226                         {AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CHECKIN},
 227
 228                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CHECKOUT},
 229                         {AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CHECKOUT},
 230
 231                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.CERTIFICATIONREQUEST},
 232                         {AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.CERTIFICATIONREQUEST},
 233
 234                         {AssetTypeEnum.SERVICES, LifeCycleStatesEnum.STARTCERTIFICATION},
 235                         {AssetTypeEnum.RESOURCES, LifeCycleStatesEnum.STARTCERTIFICATION},
 236                         };
 237         }
 238
 239         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 240         @Test(dataProvider="invalidAssetUUID")
 241         public void invalidAssetUUID(AssetTypeEnum assetTypeEnum, LifeCycleStatesEnum lifeCycleStatesEnum) throws Exception {
 242                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 243                 String assetUUID = "InvalidAssetUUID";
 244                 ErrorInfo errorInfo = null;
 245
 246                 RestResponse restResponse = null;
 247                 if(assetTypeEnum.equals(AssetTypeEnum.SERVICES)) {
 248
 249                         if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKIN)) {
 250                                 restResponse = LifecycleRestUtils.checkInService(assetUUID, defaultUser);
 251                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKOUT)) {
 252                                 restResponse = LifecycleRestUtils.checkOutService(assetUUID, defaultUser);
 253                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 254                                 restResponse = LifecycleRestUtils.certificationRequestService(assetUUID, defaultUser);
 255                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 256                                 restResponse = LifecycleRestUtils.startTestingService(assetUUID, defaultUser);
 257                         }
 258
 259                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.SERVICE_NOT_FOUND.name());
 260                 } else {
 261
 262                         if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKIN)) {
 263                                 restResponse = LifecycleRestUtils.checkInResource(assetUUID, defaultUser);
 264                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKOUT)) {
 265                                 restResponse = LifecycleRestUtils.checkOutResource(assetUUID, defaultUser);
 266                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 267                                 restResponse = LifecycleRestUtils.certificationRequestResource(assetUUID, defaultUser);
 268                         } else if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 269                                 restResponse = LifecycleRestUtils.startTestingResource(assetUUID, defaultUser);
 270                         }
 271
 272                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
 273
 274                 }
 275                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)STATUS_CODE_NOT_FOUND, "Asset found.");
 276
 277                 // auditing verification
 278                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 279                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 280                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", assetTypeEnum.getValue().toLowerCase(), assetUUID, lifeCycleStatesEnum.getState()));
 281                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultInvalidChangeAssetLifeCycleExternalAPI(assetUUID, defaultUser, lifeCycleStatesEnum, assetTypeEnum);
 282
 283                 List<String> variables = asList(assetUUID);
 284                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 285
 286                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 287         }
 288
 289         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 290
 291         @DataProvider(name="invalidUserCheckinForCheckedOutService")
 292         public static Object[][] dataProviderInvalidUserCheckinForCheckedOutService() {
 293                 return new Object[][] {
 294                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 295                         // TODO: remove comment after talk with renana if it is defect or not
 296 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 297                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 298                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 299                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 300                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 301                         };
 302         }
 303
 304         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 305         @Test(dataProvider="invalidUserCheckinForCheckedOutService")
 306         public void invalidUserCheckinForCheckedOutService(User defaultUser) throws Exception {
 307                 Component resourceDetails = null;
 308                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 309                 resourceDetails = createdComponent.left().value();
 310
 311                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), defaultUser);
 312                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 313
 314                 // auditing verification
 315                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 316                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 317                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 318                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.SERVICES);
 319                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 320                 expectedResourceAuditJavaObject.setStatus("409");
 321                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 322                 List<String> variables = asList("");
 323                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 324                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 325         }
 326
 327         @DataProvider(name="invalidUserCheckinForCheckedInService")
 328         public static Object[][] dataProviderInvalidUserCheckinForCheckedInService() {
 329                 return new Object[][] {
 330                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 331                         // TODO: remove comment after talk with renana if it is defect or not
 332 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 333                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 334                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 335                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 336                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 337                         };
 338         }
 339
 340         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 341         @Test(dataProvider="invalidUserCheckinForCheckedInService")
 342         public void invalidUserCheckinForCheckedInService(User defaultUser) throws Exception {
 343                 Component resourceDetails = null;
 344                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 345                 resourceDetails = createdComponent.left().value();
 346                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 347
 348                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), defaultUser);
 349                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 350
 351                 // auditing verification
 352                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 353                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 354                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 355                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.SERVICES);
 356                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 357                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 358                 expectedResourceAuditJavaObject.setStatus("409");
 359                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 360                 List<String> variables = asList("");
 361                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 362                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 363         }
 364
 365         @DataProvider(name="invalidUserCheckoutForCheckedOutService")
 366         public static Object[][] dataProviderInvalidUserCheckoutForCheckedOutService() {
 367                 return new Object[][] {
 368                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 369                         // TODO: remove comment after talk with renana if it is defect or not
 370 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 371                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 372                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 373                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 374                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 375                         };
 376         }
 377
 378         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 379         @Test(dataProvider="invalidUserCheckoutForCheckedOutService")
 380         public void invalidUserCheckoutForCheckedOutService(User defaultUser) throws Exception {
 381                 Component resourceDetails = null;
 382                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 383                 resourceDetails = createdComponent.left().value();
 384
 385                 RestResponse restResponse = LifecycleRestUtils.checkOutService(resourceDetails.getUUID(), defaultUser);
 386                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 387
 388                 // auditing verification
 389                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 390                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 391                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 392                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.SERVICES);
 393                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 394                 expectedResourceAuditJavaObject.setStatus("409");
 395                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 396                 List<String> variables = asList("");
 397                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 398                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 399         }
 400
 401         @DataProvider(name="invalidUserCheckoutForCheckedInService")
 402         public static Object[][] dataProviderInvalidUserCheckoutForCheckedInService() {
 403                 return new Object[][] {
 404                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 405                         // TODO: remove comment after talk with renana if it is defect or not
 406 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 407                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 408                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 409                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 410                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 411                         };
 412         }
 413
 414         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 415         @Test(dataProvider="invalidUserCheckoutForCheckedInService")
 416         public void invalidUserCheckoutForCheckedInService(User defaultUser) throws Exception {
 417                 Component resourceDetails = null;
 418                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 419                 resourceDetails = createdComponent.left().value();
 420                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 421
 422                 RestResponse restResponse = LifecycleRestUtils.checkOutService(resourceDetails.getUUID(), defaultUser);
 423                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 424
 425                 // auditing verification
 426                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 427                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 428                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 429                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.SERVICES);
 430                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 431                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 432                 expectedResourceAuditJavaObject.setStatus("409");
 433                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 434                 List<String> variables = asList("");
 435                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 436                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 437         }
 438
 439         @DataProvider(name="invalidUserCheckinForCheckedOutResource")
 440         public static Object[][] dataProviderInvalidUserCheckinForCheckedOutResource() {
 441                 return new Object[][] {
 442                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 443                         // TODO: remove comment after talk with renana if it is defect or not
 444 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 445                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 446                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 447                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 448                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 449                         };
 450         }
 451
 452         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 453         @Test(dataProvider="invalidUserCheckinForCheckedOutResource")
 454         public void invalidUserCheckinForCheckedOutResource(User defaultUser) throws Exception {
 455                 Component resourceDetails = null;
 456                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 457                 resourceDetails = createdComponent.left().value();
 458
 459                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), defaultUser);
 460                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 461
 462                 // auditing verification
 463                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 464                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 465                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 466                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.RESOURCES);
 467                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 468                 expectedResourceAuditJavaObject.setStatus("409");
 469                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 470                 List<String> variables = asList("");
 471                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 472                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 473         }
 474
 475         @DataProvider(name="invalidUserCheckinForCheckedInResource")
 476         public static Object[][] dataProviderInvalidUserCheckinForCheckedInResource() {
 477                 return new Object[][] {
 478                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 479                         // TODO: remove comment after talk with renana if it is defect or not
 480 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 481                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 482                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 483                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 484                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 485                         };
 486         }
 487
 488         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 489         @Test(dataProvider="invalidUserCheckinForCheckedInResource")
 490         public void invalidUserCheckinForCheckedInResource(User defaultUser) throws Exception {
 491                 Component resourceDetails = null;
 492                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 493                 resourceDetails = createdComponent.left().value();
 494                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 495
 496                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), defaultUser);
 497                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 498
 499                 // auditing verification
 500                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 501                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 502                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 503                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.RESOURCES);
 504                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 505                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 506                 expectedResourceAuditJavaObject.setStatus("409");
 507                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 508                 List<String> variables = asList("");
 509                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 510                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 511         }
 512
 513         @DataProvider(name="invalidUserCheckoutForCheckedOutResource")
 514         public static Object[][] dataProviderInvalidUserCheckoutForCheckedOutResource() {
 515                 return new Object[][] {
 516                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 517                         // TODO: remove comment after talk with renana if it is defect or not
 518 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 519                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 520                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 521                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 522                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 523                         };
 524         }
 525
 526         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 527         @Test(dataProvider="invalidUserCheckoutForCheckedOutResource")
 528         public void invalidUserCheckoutForCheckedOutResource(User defaultUser) throws Exception {
 529                 Component resourceDetails = null;
 530                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 531                 resourceDetails = createdComponent.left().value();
 532
 533                 RestResponse restResponse = LifecycleRestUtils.checkOutResource(resourceDetails.getUUID(), defaultUser);
 534                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 535
 536                 // auditing verification
 537                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 538                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 539                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 540                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.RESOURCES);
 541                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
 542                 expectedResourceAuditJavaObject.setStatus("409");
 543                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 544                 List<String> variables = asList("");
 545                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 546                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 547         }
 548
 549         @DataProvider(name="invalidUserCheckoutForCheckedInResource")
 550         public static Object[][] dataProviderInvalidUserCheckoutForCheckedInResource() {
 551                 return new Object[][] {
 552                         {ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 553                         // TODO: remove comment after talk with renana if it is defect or not
 554 //                      {ElementFactory.getDefaultUser(UserRoleEnum.ADMIN)},
 555                         {ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR)},
 556                         {ElementFactory.getDefaultUser(UserRoleEnum.OPS)},
 557                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1)},
 558                         {ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1)},
 559                         };
 560         }
 561
 562         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 563         @Test(dataProvider="invalidUserCheckoutForCheckedInResource")
 564         public void invalidUserCheckoutForCheckedInResource(User defaultUser) throws Exception {
 565                 Component resourceDetails = null;
 566                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 567                 resourceDetails = createdComponent.left().value();
 568                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 569
 570                 RestResponse restResponse = LifecycleRestUtils.checkOutResource(resourceDetails.getUUID(), defaultUser);
 571                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)RESTRICTED_OPERATION, "Expected for restricted operation.");
 572
 573                 // auditing verification
 574                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 575                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 576                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 577                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.RESOURCES);
 578                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 579                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 580                 expectedResourceAuditJavaObject.setStatus("409");
 581                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 582                 List<String> variables = asList("");
 583                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 584                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 585         }
 586
 587         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 588         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 589         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 590
 591
 592
 593
 594         @DataProvider(name="invalidStatesForService")
 595         public static Object[][] dataProviderInvalidStatesForService() {
 596                 return new Object[][] {
 597                         {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},
 598                         {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},
 599                         {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},
 600
 601                         {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},
 602                         {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},
 603                         {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},
 604
 605                         {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},
 606                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, LifeCycleStatesEnum.CERTIFY, RESTRICTED_OPERATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, "409", ActionStatus.RESTRICTED_OPERATION, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 607
 608                         {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)},
 609                         {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)},
 610                         {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)},
 611                         {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},
 612
 613                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CHECKIN, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 614                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 615                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 616                         {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},
 617                 };
 618         }
 619
 620         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 621         @Test(dataProvider="invalidStatesForService")
 622         public void invalidStatesForService(LifeCycleStatesEnum initState, LifeCycleStatesEnum targetState, int errorCode,
 623                         LifecycleStateEnum preState, LifecycleStateEnum currState, String status,
 624                         ActionStatus actionStatus, User user, User operationUser) throws Exception {
 625
 626                 if(initState.equals(LifeCycleStatesEnum.STARTCERTIFICATION) && targetState.equals(LifeCycleStatesEnum.CHECKIN)){
 627                         throw new SkipException("Open bug DE270217");
 628                 }
 629
 630                 getExtendTest().log(Status.INFO, String.format("initState: %s, targetState: %s, errorCode: %s,"
 631                                 + " preState: %s, currState: %s, status: %s, actionStatus: %s, user: %s, operationUser: %s", initState, targetState, errorCode, preState,
 632                                 currState, status, actionStatus, user, operationUser));
 633
 634
 635                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 636                 Component resourceDetails = createdComponent.left().value();
 637
 638                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, initState, true).getLeft();
 639
 640                 RestResponse restResponse = null;
 641
 642                 if(targetState.equals(LifeCycleStatesEnum.CHECKOUT)) {
 643                         restResponse = LifecycleRestUtils.checkOutService(resourceDetails.getUUID(), user);
 644                 } else if(targetState.equals(LifeCycleStatesEnum.CHECKIN)) {
 645                         restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), user);
 646                 } else if(targetState.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 647                         restResponse = LifecycleRestUtils.certificationRequestService(resourceDetails.getUUID(), user);
 648                 } else if(targetState.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 649                         restResponse = LifecycleRestUtils.startTestingService(resourceDetails.getUUID(), user);
 650                 } else if(targetState.equals(LifeCycleStatesEnum.CERTIFY)) {
 651                         restResponse = LifecycleRestUtils.certifyService(resourceDetails.getUUID(), user);
 652                 }
 653
 654                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)errorCode, "Expected that response code will be equal.");
 655
 656                 // auditing verification
 657                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 658                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 659                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 660                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, user, targetState, AssetTypeEnum.SERVICES);
 661                 if(initState.equals(LifeCycleStatesEnum.CERTIFY)) {
 662                         expectedResourceAuditJavaObject.setCurrVersion("1.0");
 663                         expectedResourceAuditJavaObject.setPrevVersion("1.0");
 664                 }
 665                 expectedResourceAuditJavaObject.setPrevState(preState.toString());
 666                 expectedResourceAuditJavaObject.setCurrState(currState.toString());
 667                 expectedResourceAuditJavaObject.setStatus(status);
 668                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(actionStatus.name());
 669                 List<String> variables = null;
 670                 if(ActionStatus.RESTRICTED_OPERATION.equals(actionStatus)) {
 671                         variables = asList("");
 672                 } else if(ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION.equals(actionStatus)) {
 673                         variables = asList(resourceDetails.getName(), AssetTypeEnum.SERVICES.getCorrespondingComponent().toLowerCase());
 674                 } else {
 675                         if(operationUser == null) {
 676                                 variables = asList(resourceDetails.getName(), AssetTypeEnum.SERVICES.getCorrespondingComponent().toLowerCase(), user.getFirstName(), user.getLastName(), user.getUserId());
 677                         } else {
 678                                 variables = asList(resourceDetails.getName(), AssetTypeEnum.SERVICES.getCorrespondingComponent().toLowerCase(), operationUser.getFirstName(), operationUser.getLastName(), operationUser.getUserId());
 679                         }
 680
 681                 }
 682                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 683                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 684         }
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699         @DataProvider(name="invalidStatesForResource")
 700         public static Object[][] dataProviderInvalidStatesForResource() {
 701                 return new Object[][] {
 702                         {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},
 703                         {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},
 704                         {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},
 705
 706                         {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},
 707                         {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},
 708                         {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},
 709
 710                         {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},
 711                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, LifeCycleStatesEnum.CERTIFY, RESTRICTED_OPERATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, LifecycleStateEnum.READY_FOR_CERTIFICATION, "409", ActionStatus.RESTRICTED_OPERATION, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), null},
 712
 713                         {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)},
 714                         {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)},
 715                         {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)},
 716                         {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},
 717
 718                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CHECKIN, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 719                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.CERTIFICATIONREQUEST, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ElementFactory.getDefaultUser(UserRoleEnum.TESTER)},
 720                         {LifeCycleStatesEnum.CERTIFY, LifeCycleStatesEnum.STARTCERTIFICATION, COMPONENT_ALREADY_CERTIFIED, LifecycleStateEnum.CERTIFIED, LifecycleStateEnum.CERTIFIED, "403", ActionStatus.COMPONENT_ALREADY_CERTIFIED, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), null},
 721                         {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},
 722                 };
 723         }
 724
 725         // US849997 - Story [BE]: External API for asset lifecycle - checkout
 726         @Test(dataProvider="invalidStatesForResource")
 727         public void invalidStatesForResource(LifeCycleStatesEnum initState, LifeCycleStatesEnum targetState, int errorCode,
 728                         LifecycleStateEnum preState, LifecycleStateEnum currState, String status,
 729                         ActionStatus actionStatus, User user, User operationUser) throws Exception {
 730                 getExtendTest().log(Status.INFO, String.format("initState: %s, targetState: %s, errorCode: %s,"
 731                                 + " preState: %s, currState: %s, status: %s, actionStatus: %s, user: %s, operationUser: %s", initState, targetState, errorCode, preState,
 732                                 currState, status, actionStatus, user, operationUser));
 733
 734                 if(initState.equals(LifeCycleStatesEnum.STARTCERTIFICATION) && targetState.equals(LifeCycleStatesEnum.CHECKIN)){
 735                         throw new SkipException("Open bug DE270217");
 736                 }
 737
 738                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 739                 Component resourceDetails = createdComponent.left().value();
 740
 741                 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, UserRoleEnum.DESIGNER, initState, true).getLeft();
 742
 743                 RestResponse restResponse = null;
 744
 745                 if(targetState.equals(LifeCycleStatesEnum.CHECKOUT)) {
 746                         restResponse = LifecycleRestUtils.checkOutResource(resourceDetails.getUUID(), user);
 747                 } else if(targetState.equals(LifeCycleStatesEnum.CHECKIN)) {
 748                         restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), user);
 749                 } else if(targetState.equals(LifeCycleStatesEnum.CERTIFICATIONREQUEST)) {
 750                         restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), user);
 751                 } else if(targetState.equals(LifeCycleStatesEnum.STARTCERTIFICATION)) {
 752                         restResponse = LifecycleRestUtils.startTestingResource(resourceDetails.getUUID(), user);
 753                 } else if(targetState.equals(LifeCycleStatesEnum.CERTIFY)) {
 754                         restResponse = LifecycleRestUtils.certifyResource(resourceDetails.getUUID(), user);
 755                 }
 756
 757                 Assert.assertEquals(restResponse.getErrorCode(), (Integer)errorCode, "Expected that response code will be equal.");
 758
 759                 // auditing verification
 760                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 761                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 762                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 763                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, user, targetState, AssetTypeEnum.RESOURCES);
 764                 if(initState.equals(LifeCycleStatesEnum.CERTIFY)) {
 765                         expectedResourceAuditJavaObject.setCurrVersion("1.0");
 766                         expectedResourceAuditJavaObject.setPrevVersion("1.0");
 767                 }
 768                 expectedResourceAuditJavaObject.setPrevState(preState.toString());
 769                 expectedResourceAuditJavaObject.setCurrState(currState.toString());
 770                 expectedResourceAuditJavaObject.setStatus(status);
 771                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(actionStatus.name());
 772                 List<String> variables = null;
 773                 if(ActionStatus.RESTRICTED_OPERATION.equals(actionStatus)) {
 774                         variables = asList("");
 775                 } else if(ActionStatus.COMPONENT_NOT_READY_FOR_CERTIFICATION.equals(actionStatus)) {
 776                         variables = asList(resourceDetails.getName(), AssetTypeEnum.RESOURCES.getCorrespondingComponent().toLowerCase());
 777                 } else {
 778                         if(operationUser == null) {
 779                                 variables = asList(resourceDetails.getName(), AssetTypeEnum.RESOURCES.getCorrespondingComponent().toLowerCase(), user.getFirstName(), user.getLastName(), user.getUserId());
 780                         } else {
 781                                 variables = asList(resourceDetails.getName(), AssetTypeEnum.RESOURCES.getCorrespondingComponent().toLowerCase(), operationUser.getFirstName(), operationUser.getLastName(), operationUser.getUserId());
 782                         }
 783
 784                 }
 785                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 786                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 787         }
 788
 789
 790
 791
 792         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 793         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 794         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 795
 796         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 797         @Test
 798         public void BasicFlowForResourceSubmitForTestingStartTesting() throws Exception {
 799                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 800                 Component resourceDetails = createdComponent.left().value();
 801                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 802
 803                 // Certification request
 804                 restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 805
 806                 // Auditing verification
 807                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 808                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 809                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 810                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.CERTIFICATIONREQUEST.getState()));
 811                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CERTIFICATIONREQUEST, AssetTypeEnum.RESOURCES);
 812                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 813                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.READY_FOR_CERTIFICATION.toString());
 814                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 815
 816                 // Start testing
 817                 restResponse = LifecycleRestUtils.startTestingResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 818
 819                 // Auditing verification
 820                 body = new HashMap<>();
 821                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 822                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.STARTCERTIFICATION.getState()));
 823                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION, AssetTypeEnum.RESOURCES);
 824                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.READY_FOR_CERTIFICATION.toString());
 825                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.toString());
 826                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 827         }
 828
 829         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 830         @Test
 831         public void BasicFlowForServiceSubmitForTestingStartTesting() throws Exception {
 832                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 833                 Component resourceDetails = createdComponent.left().value();
 834                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 835
 836                 // Certification request
 837                 restResponse = LifecycleRestUtils.certificationRequestService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 838
 839                 // Auditing verification
 840                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 841                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 842                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 843                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.SERVICES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.CERTIFICATIONREQUEST.getState()));
 844                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CERTIFICATIONREQUEST, AssetTypeEnum.SERVICES);
 845                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 846                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.READY_FOR_CERTIFICATION.toString());
 847                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 848
 849                 // Start testing
 850                 restResponse = LifecycleRestUtils.startTestingService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 851
 852                 // Auditing verification
 853                 body = new HashMap<>();
 854                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 855                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.SERVICES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.STARTCERTIFICATION.getState()));
 856                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION, AssetTypeEnum.SERVICES);
 857                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.READY_FOR_CERTIFICATION.toString());
 858                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.toString());
 859                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 860         }
 861
 862         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 863         @Test
 864         public void specialCaseInvalidFlowForVfcmtSubmitForTesting() throws Exception {
 865                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VFCMT, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 866                 Component resourceDetails = createdComponent.left().value();
 867                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 868
 869                 // Certification request
 870                 restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 871
 872                 // Auditing verification
 873                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 874                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 875                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 876                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.CERTIFICATIONREQUEST.getState()));
 877                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, defaultUser, LifeCycleStatesEnum.CERTIFICATIONREQUEST, AssetTypeEnum.RESOURCES);
 878                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 879                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 880                 expectedResourceAuditJavaObject.setStatus("400");
 881
 882                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_VFCMT_LIFECYCLE_STATE_NOT_VALID.name());
 883                 List<String> variables = asList(LifeCycleStatesEnum.CERTIFICATIONREQUEST.getState());
 884                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 885
 886                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 887         }
 888
 889         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 890         @Test
 891         public void specialCaseInvalidFlowForVfcmtStartTesting() throws Exception {
 892                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VFCMT, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 893                 Component resourceDetails = createdComponent.left().value();
 894                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 895
 896                 // Certification request
 897                 restResponse = LifecycleRestUtils.startTestingResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 898
 899                 // Auditing verification
 900                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 901                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 902                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 903                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.STARTCERTIFICATION.getState()));
 904                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.STARTCERTIFICATION, AssetTypeEnum.RESOURCES);
 905                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 906                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
 907                 expectedResourceAuditJavaObject.setStatus("400");
 908
 909                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_VFCMT_LIFECYCLE_STATE_NOT_VALID.name());
 910                 List<String> variables = asList(LifeCycleStatesEnum.STARTCERTIFICATION.getState());
 911                 expectedResourceAuditJavaObject.setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 912
 913                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 914         }
 915
 916
 917
 918         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 919         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 920         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 921
 922
 923
 924
 925         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 926         @Test
 927         public void BasicFlowForResourceCertify() throws Exception {
 928                 Either<Resource, RestResponse> createdComponent = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, UserRoleEnum.DESIGNER, true);
 929                 Component resourceDetails = createdComponent.left().value();
 930                 RestResponse restResponse = LifecycleRestUtils.checkInResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 931
 932                 // Certification request
 933                 restResponse = LifecycleRestUtils.certificationRequestResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 934
 935                 // Start testing
 936                 restResponse = LifecycleRestUtils.startTestingResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 937
 938                 // Certify
 939                 restResponse = LifecycleRestUtils.certifyResource(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 940
 941                 // Auditing verification
 942                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 943                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 944                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 945                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.CERTIFY.getState()));
 946                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY, AssetTypeEnum.RESOURCES);
 947                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.toString());
 948                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.toString());
 949                 expectedResourceAuditJavaObject.setCurrVersion("1.0");
 950                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 951
 952         }
 953
 954         // US824692 - Story [BE]: External API for asset lifecycle - submit for test / start testing
 955         @Test
 956         public void BasicFlowForServiceCertify() throws Exception {
 957                 Either<Service, RestResponse> createdComponent = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
 958                 Component resourceDetails = createdComponent.left().value();
 959                 RestResponse restResponse = LifecycleRestUtils.checkInService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 960
 961                 // Certification request
 962                 restResponse = LifecycleRestUtils.certificationRequestService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 963
 964                 // Start testing
 965                 restResponse = LifecycleRestUtils.startTestingService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 966
 967                 // Certify
 968                 restResponse = LifecycleRestUtils.certifyService(resourceDetails.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER));
 969
 970                 // Auditing verification
 971                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
 972                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 973                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 974                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.SERVICES.getValue().toLowerCase(), resourceDetails.getUUID(), LifeCycleStatesEnum.CERTIFY.getState()));
 975                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), LifeCycleStatesEnum.CERTIFY, AssetTypeEnum.SERVICES);
 976                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.toString());
 977                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.toString());
 978                 expectedResourceAuditJavaObject.setCurrVersion("1.0");
 979                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
 980         }
 981
 982
 983
 984
 985
 986
 987
 988
 989         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 990         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 991         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 992
 993         @Test
 994         public void theFlow() throws Exception {
 995                 User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 996                 ResourceExternalReqDetails defaultResource = ElementFactory.getDefaultResourceByType("ci", ResourceCategoryEnum.TEMPLATE_MONITORING_TEMPLATE, defaultUser.getUserId(), ResourceTypeEnum.VFCMT.toString());
 997
 998                 // 1. Create VFCMT.
 999                 RestResponse restResponse = ResourceRestUtilsExternalAPI.createResource(defaultResource, defaultUser);
1000                 BaseRestUtils.checkCreateResponse(restResponse);
1001                 ResourceAssetStructure parsedCreatedResponse = gson.fromJson(restResponse.getResponse(), ResourceAssetStructure.class);
1002
1003                 // 2. Using search external API with resourceType=VFCMT to retrieve VFCMT.
1004                 restResponse = ResourceRestUtils.getResourceListFilterByCriteria(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), SearchCriteriaEnum.RESOURCE_TYPE.getValue(), ResourceTypeEnum.VFCMT.toString());
1005                 BaseRestUtils.checkSuccess(restResponse);
1006                 ResourceAssetStructure dataOutOfSearchResponseForResourceName = ResponseParser.getDataOutOfSearchExternalAPIResponseForResourceName(restResponse.getResponse(), parsedCreatedResponse.getName());
1007                 Assert.assertEquals(parsedCreatedResponse.getUuid(), dataOutOfSearchResponseForResourceName.getUuid(), "Created resourceUUID not equal to search retrive resourceUUID.");
1008
1009                 // 3. Use getSpecificMetadata external API to receive full information of the VFCMT.
1010                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES, dataOutOfSearchResponseForResourceName.getUuid());
1011                 BaseRestUtils.checkSuccess(assetResponse);
1012                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
1013                 Assert.assertEquals(resourceAssetMetadata.getUuid(), parsedCreatedResponse.getUuid(), "Created resourceUUID not equal to getSpecificMetadata resourceUUID.");
1014
1015                 // 4. Upload artifact via upload artifact external API.
1016                 Component initComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), parsedCreatedResponse.getVersion());
1017                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", "OTHER", true, false);
1018                 RestResponse uploadArtifactRestResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(initComponentVersion, defaultUser, artifactReqDetails);
1019                 BaseRestUtils.checkSuccess(uploadArtifactRestResponse);
1020                 ArtifactDefinition responseArtifact = ArtifactRestUtils.getArtifactDataFromJson(uploadArtifactRestResponse.getResponse());
1021                 initComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), parsedCreatedResponse.getVersion());
1022
1023                 // 5. Update artifact via external API.
1024                 CRUDExternalAPI crudExternalAPI = new CRUDExternalAPI();
1025                 crudExternalAPI.updateArtifactOnAssetViaExternalAPI(initComponentVersion, ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, "OTHER");
1026
1027
1028                 // 6. Use external API to checkin the VFCMT.
1029                 RestResponse checkInRestResponse = LifecycleRestUtils.checkInResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1030                 BaseRestUtils.checkCreateResponse(checkInRestResponse);
1031                 parsedCreatedResponse = gson.fromJson(checkInRestResponse.getResponse(), ResourceAssetStructure.class);
1032                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "0.1", "Expect that version will not change.");
1033                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
1034                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
1035
1036                 // Auditing verification
1037                 AuditingActionEnum action = AuditingActionEnum.CHANGE_LIFECYCLE_BY_API;
1038                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
1039                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, initComponentVersion.getName());
1040                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), initComponentVersion.getUUID(), LifeCycleStatesEnum.CHECKIN.getState()));
1041                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(initComponentVersion, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.RESOURCES);
1042                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
1043
1044                 // 7. Then checkout the VFCMT via external API.
1045                 RestResponse checkOutRestResponse = LifecycleRestUtils.checkOutResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1046                 BaseRestUtils.checkCreateResponse(checkOutRestResponse);
1047                 parsedCreatedResponse = gson.fromJson(checkOutRestResponse.getResponse(), ResourceAssetStructure.class);
1048                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "0.2", "Expect that version will change to 0.2.");
1049                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
1050                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
1051
1052                 // Auditing verification
1053                 body = new HashMap<>();
1054                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, initComponentVersion.getName());
1055                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), initComponentVersion.getUUID(), LifeCycleStatesEnum.CHECKOUT.getState()));
1056                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(initComponentVersion, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.RESOURCES);
1057                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
1058                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
1059                 expectedResourceAuditJavaObject.setCurrVersion("0.2");
1060                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
1061
1062                 // 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.
1063                 Component newComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), String.format("%.1f", Double.parseDouble(parsedCreatedResponse.getVersion())));
1064                 Assert.assertEquals(newComponentVersion.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
1065                 Assert.assertEquals(newComponentVersion.getUUID(), initComponentVersion.getUUID(), "Expected that UUID will not change.");
1066                 Assert.assertNotEquals(newComponentVersion.getUniqueId(), initComponentVersion.getUniqueId(), "Expected that uniqueId will change.");
1067                 Assert.assertTrue(newComponentVersion.getDeploymentArtifacts().keySet().contains(responseArtifact.getArtifactLabel()), "Expected that artifact from first version exists on the new version.");
1068
1069                 // 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.
1070                 initComponentVersion = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, parsedCreatedResponse.getName(), String.format("%.1f", Double.parseDouble("0.1")));
1071                 Assert.assertEquals(initComponentVersion.isHighestVersion(), (Boolean)false, "Expected that highest version flag on first version is false.");
1072
1073                 // 10. Check in via external API.
1074                 checkInRestResponse = LifecycleRestUtils.checkInResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1075                 BaseRestUtils.checkCreateResponse(checkInRestResponse);
1076                 parsedCreatedResponse = gson.fromJson(checkInRestResponse.getResponse(), ResourceAssetStructure.class);
1077                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "0.2", "Expect that version will not change.");
1078                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
1079                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
1080
1081                 // Auditing verification
1082                 body = new HashMap<>();
1083                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, initComponentVersion.getName());
1084                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), initComponentVersion.getUUID(), LifeCycleStatesEnum.CHECKIN.getState()));
1085                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(initComponentVersion, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN, AssetTypeEnum.RESOURCES);
1086                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
1087                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
1088                 expectedResourceAuditJavaObject.setCurrVersion("0.2");
1089                 expectedResourceAuditJavaObject.setPrevVersion("0.2");
1090                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
1091
1092                 // 11. Certify via external API.
1093                 RestResponse certifyRestResponse = LifecycleRestUtils.certifyResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1094                 BaseRestUtils.checkCreateResponse(certifyRestResponse);
1095                 parsedCreatedResponse = gson.fromJson(certifyRestResponse.getResponse(), ResourceAssetStructure.class);
1096                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "1.0", "Expect that version will change to 1.0");
1097                 Assert.assertEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will not change.");
1098                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
1099
1100                 // Auditing verification
1101                 body = new HashMap<>();
1102                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, initComponentVersion.getName());
1103                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), initComponentVersion.getUUID(), LifeCycleStatesEnum.CERTIFY.getState()));
1104                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(initComponentVersion, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CERTIFY, AssetTypeEnum.RESOURCES);
1105                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.toString());
1106                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.toString());
1107                 expectedResourceAuditJavaObject.setCurrVersion("1.0");
1108                 expectedResourceAuditJavaObject.setPrevVersion("0.2");
1109                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
1110
1111                 // 12. Check out via external API.
1112                 checkOutRestResponse = LifecycleRestUtils.checkOutResource(initComponentVersion.getUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1113                 BaseRestUtils.checkCreateResponse(checkOutRestResponse);
1114                 parsedCreatedResponse = gson.fromJson(checkOutRestResponse.getResponse(), ResourceAssetStructure.class);
1115                 Assert.assertEquals(parsedCreatedResponse.getVersion(), "1.1", "Expect that version will change to 1.1");
1116                 Assert.assertNotEquals(parsedCreatedResponse.getUuid(), initComponentVersion.getUUID(), "Expect that UUID will change.");
1117                 Assert.assertEquals(parsedCreatedResponse.getInvariantUUID(), initComponentVersion.getInvariantUUID(), "Expected that invariantUUID will not change.");
1118
1119                 // Auditing verification
1120                 body = new HashMap<>();
1121                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, initComponentVersion.getName());
1122                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, String.format("/sdc/v1/catalog/%s/%s/lifecycleState/%s", AssetTypeEnum.RESOURCES.getValue().toLowerCase(), initComponentVersion.getUUID(), LifeCycleStatesEnum.CHECKOUT.getState()));
1123                 expectedResourceAuditJavaObject = ElementFactory.getDefaultChangeAssetLifeCycleExternalAPI(initComponentVersion, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKOUT, AssetTypeEnum.RESOURCES);
1124                 expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFIED.toString());
1125                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.toString());
1126                 expectedResourceAuditJavaObject.setCurrVersion("1.1");
1127                 expectedResourceAuditJavaObject.setPrevVersion("1.0");
1128                 AuditValidationUtils.validateAuditExternalChangeAssetLifeCycle(expectedResourceAuditJavaObject, action.getName(), body);
1129
1130
1131         }
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146 }