test-apis-ci/src/main/java/org/openecomp/sdc/externalApis/AssetLifeCycle.java

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