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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.externalApis;
  22
  23 import static java.util.Arrays.asList;
  24
  25 import java.io.IOException;
  26 import java.io.UnsupportedEncodingException;
  27 import java.util.Arrays;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import org.apache.commons.lang3.StringUtils;
  33 import org.apache.http.HttpEntity;
  34 import org.apache.http.HttpResponse;
  35 import org.apache.http.client.HttpResponseException;
  36 import org.apache.http.client.methods.CloseableHttpResponse;
  37 import org.apache.http.client.methods.HttpDelete;
  38 import org.apache.http.client.methods.HttpGet;
  39 import org.apache.http.client.methods.HttpPost;
  40 import org.apache.http.entity.StringEntity;
  41 import org.apache.http.impl.client.BasicResponseHandler;
  42 import org.apache.http.util.EntityUtils;
  43 import org.codehaus.jackson.map.DeserializationConfig;
  44 import org.codehaus.jackson.map.ObjectMapper;
  45 import org.codehaus.jackson.map.SerializationConfig.Feature;
  46 import org.codehaus.jackson.map.annotate.JsonSerialize;
  47 import org.json.simple.JSONObject;
  48 import org.json.simple.parser.JSONParser;
  49 import org.json.simple.parser.ParseException;
  50 import org.junit.Rule;
  51 import org.junit.rules.TestName;
  52 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  53 import org.openecomp.sdc.be.dao.api.ActionStatus;
  54 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
  55 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  57 import org.openecomp.sdc.be.model.ArtifactDefinition;
  58 import org.openecomp.sdc.be.model.ArtifactUiDownloadData;
  59 import org.openecomp.sdc.be.model.Component;
  60 import org.openecomp.sdc.be.model.ComponentInstance;
  61 import org.openecomp.sdc.be.model.Resource;
  62 import org.openecomp.sdc.be.model.Service;
  63 import org.openecomp.sdc.be.model.User;
  64 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  65 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  66 import org.openecomp.sdc.ci.tests.config.Config;
  67 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  68 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  69 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  70 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  71 import org.openecomp.sdc.ci.tests.datatypes.enums.DistributionNotificationStatusEnum;
  72 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  73 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  74 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  75 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  76 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  77 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedExternalAudit;
  78 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  79 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  80 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  81 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  82 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  83 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  84 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  85 import org.openecomp.sdc.ci.tests.utils.validation.DistributionValidationUtils;
  86 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  87 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  88 import org.openecomp.sdc.common.api.Constants;
  89 import org.openecomp.sdc.common.config.EcompErrorName;
  90 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  91 import org.openecomp.sdc.common.util.GeneralUtility;
  92 import org.slf4j.Logger;
  93 import org.slf4j.LoggerFactory;
  94 import org.testng.Assert;
  95 import org.testng.SkipException;
  96 import org.testng.annotations.DataProvider;
  97 import org.testng.annotations.Test;
  98
  99 import com.aventstack.extentreports.Status;
 100 import com.google.gson.Gson;
 101 import com.google.gson.JsonElement;
 102 import com.google.gson.JsonObject;
 103
 104 import fj.data.Either;
 105
 106 public class CRUDExternalAPI extends ComponentBaseTest {
 107
 108         private static Logger log = LoggerFactory.getLogger(CRUDExternalAPI.class.getName());
 109         protected static final String UPLOAD_ARTIFACT_PAYLOAD = "UHVUVFktVXNlci1LZXktRmlsZS0yOiBzc2gtcnNhDQpFbmNyeXB0aW9uOiBhZXMyNTYtY2JjDQpDb21tZW5wOA0K";
 110         protected static final String UPLOAD_ARTIFACT_NAME = "TLV_prv.ppk";
 111
 112         protected Config config = Config.instance();
 113         protected String contentTypeHeaderData = "application/json";
 114         protected String acceptHeaderDate = "application/json";
 115
 116         protected Gson gson = new Gson();
 117         protected JSONParser jsonParser = new JSONParser();
 118
 119         protected String serviceVersion;
 120         protected ResourceReqDetails resourceDetails;
 121         protected User sdncUserDetails;
 122         protected ServiceReqDetails serviceDetails;
 123
 124         @Rule
 125         public static TestName name = new TestName();
 126
 127         public CRUDExternalAPI() {
 128                 super(name, CRUDExternalAPI.class.getName());
 129         }
 130
 131         @DataProvider(name="uploadArtifactOnVfcVlCpViaExternalAPI" , parallel=true)
 132         public static Object[][] dataProviderUploadArtifactOnVfcVlCpViaExternalAPI() {
 133                 return new Object[][] {
 134                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VFC},
 135                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VFC},
 136                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VFC},
 137                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
 138                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
 139                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
 140                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VFC},
 141                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
 142                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
 143
 144                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VL},
 145                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VL},
 146                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VL},
 147                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VL},
 148                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
 149                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
 150                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VL},
 151                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
 152                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
 153
 154                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.CP},
 155                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.CP},
 156                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.CP},
 157                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.CP},
 158                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
 159                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
 160                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.CP},
 161                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
 162                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
 163
 164                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VFC},
 165                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VFC},
 166                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VFC},
 167                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
 168                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
 169                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
 170                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VFC},
 171                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
 172                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
 173
 174                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VL},
 175                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VL},
 176                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VL},
 177                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VL},
 178                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
 179                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
 180                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VL},
 181                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
 182                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
 183
 184                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.CP},
 185                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.CP},
 186                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.CP},
 187                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.CP},
 188                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
 189                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
 190                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.CP},
 191                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
 192                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
 193
 194                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VFC},
 195                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VFC},
 196                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VFC},
 197                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
 198                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
 199                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
 200                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VFC},
 201                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
 202                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
 203
 204                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VL},
 205                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VL},
 206                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VL},
 207                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VL},
 208                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
 209                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
 210                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VL},
 211                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
 212                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
 213
 214                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.CP},
 215                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.CP},
 216                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.CP},
 217                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.CP},
 218                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
 219                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
 220                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.CP},
 221                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
 222                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
 223                         };
 224         }
 225
 226         // External API
 227         // Upload artifact on VFC, VL, CP via external API - happy flow
 228         @Test(dataProvider="uploadArtifactOnVfcVlCpViaExternalAPI")
 229         public void uploadArtifactOnVfcVlCpViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
 230                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s, resourceTypeEnum: %s", chosenLifeCycleState, artifactType, resourceTypeEnum));
 231                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, chosenLifeCycleState, artifactType, resourceTypeEnum);
 232         }
 233
 234         @DataProvider(name="uploadArtifactOnVFViaExternalAPI", parallel=true)
 235         public static Object[][] dataProviderUploadArtifactOnVFViaExternalAPI() {
 236                 return new Object[][] {
 237                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_JSON"},
 238                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_POLICY"},
 239                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_EVENT"},
 240                         {LifeCycleStatesEnum.CHECKOUT, "APPC_CONFIG"},
 241                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_DOC"},
 242                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_TOSCA"},
 243                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
 244                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
 245                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE"},
 246                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE"},
 247                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
 248                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
 249                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
 250
 251                         {LifeCycleStatesEnum.CHECKIN, "DCAE_JSON"},
 252                         {LifeCycleStatesEnum.CHECKIN, "DCAE_POLICY"},
 253                         {LifeCycleStatesEnum.CHECKIN, "DCAE_EVENT"},
 254                         {LifeCycleStatesEnum.CHECKIN, "APPC_CONFIG"},
 255                         {LifeCycleStatesEnum.CHECKIN, "DCAE_DOC"},
 256                         {LifeCycleStatesEnum.CHECKIN, "DCAE_TOSCA"},
 257                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
 258                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
 259                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE"},
 260                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE"},
 261                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
 262                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
 263                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
 264
 265                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_JSON"},
 266                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_POLICY"},
 267                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_EVENT"},
 268                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "APPC_CONFIG"},
 269                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_DOC"},
 270                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_TOSCA"},
 271                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
 272                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
 273                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE"},
 274                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE"},
 275                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
 276                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
 277                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"}
 278                         };
 279         }
 280
 281         // External API
 282         // Upload artifact on VF via external API - happy flow
 283         @Test(dataProvider="uploadArtifactOnVFViaExternalAPI")
 284         public void uploadArtifactOnVFViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
 285                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 286                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, chosenLifeCycleState, artifactType, null);
 287         }
 288
 289
 290         @DataProvider(name="uploadArtifactOnServiceViaExternalAPI" , parallel=true)
 291         public static Object[][] dataProviderUploadArtifactOnServiceViaExternalAPI() {
 292                 return new Object[][] {
 293                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
 294                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
 295                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
 296                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
 297                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
 298                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
 299                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
 300                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
 301                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
 302                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
 303                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
 304                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
 305                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
 306                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
 307                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"}
 308                         };
 309         }
 310
 311
 312         @Test(dataProvider="uploadArtifactOnServiceViaExternalAPI")
 313         public void uploadArtifactOnServiceViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
 314                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 315                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.SERVICE, chosenLifeCycleState, artifactType, null);
 316         }
 317
 318
 319         @DataProvider(name="uploadArtifactOnServiceViaExternalAPIIncludingDistribution", parallel=true)
 320         public static Object[][] dataProviderUploadArtifactOnServiceViaExternalAPIIncludingDistribution() {
 321                 return new Object[][] {
 322                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
 323                         };
 324         }
 325
 326         @Test(dataProvider="uploadArtifactOnServiceViaExternalAPIIncludingDistribution")
 327         public void uploadArtifactOnServiceViaExternalAPIIncludingDistribution(LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
 328                 if(true){
 329                         throw new SkipException("Automated TC need repair.");
 330                 }
 331
 332                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 333                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.SERVICE, chosenLifeCycleState, artifactType, null);
 334
 335                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 336
 337                 if(config.getIsDistributionClientRunning()){
 338                         List<String> distributionStatusList = Arrays.asList(DistributionNotificationStatusEnum.DOWNLOAD_OK.toString(), DistributionNotificationStatusEnum.DEPLOY_OK.toString(), DistributionNotificationStatusEnum.NOTIFIED.toString());
 339                         DistributionValidationUtils.validateDistributedArtifactsByAudit((Service)component, distributionStatusList);
 340                 }
 341         }
 342
 343
 344         // Happy flow - get chosen life cycle state, artifact type and asset type
 345         // Create asset, upload artifact via external API + check audit & response code
 346         // Download artifact via external API + check audit & response code
 347         protected Component uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
 348                 Component component = null;
 349                 RestResponse restResponse;
 350                 int numberOfArtifact = 0;
 351
 352                 // get artifact data
 353                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, false);
 354
 355                 // create component/s & upload artifact via external api
 356                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
 357                         component = getComponentWithResourceInstanceInTargetLifeCycleState(chosenLifeCycleState, resourceTypeEnum);
 358                         restResponse = uploadArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
 359                         component = getNewerVersionOfComponent(component, chosenLifeCycleState);
 360                         numberOfArtifact = (component.getComponentInstances().get(0).getDeploymentArtifacts() == null ? 0 : component.getComponentInstances().get(0).getDeploymentArtifacts().size());
 361                 } else {
 362                         component = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, chosenLifeCycleState, resourceTypeEnum);
 363                         restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
 364                         component = updateComponentDetailsByLifeCycleState(chosenLifeCycleState, component);
 365                         numberOfArtifact = component.getDeploymentArtifacts().size();
 366                 }
 367
 368                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
 369                 // Get list of deployment artifact + download them via external API
 370                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
 371                 Assert.assertEquals(numberOfArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifacts will be increase by one.");
 372
 373                 // Download the uploaded artifact via external API
 374                 downloadResourceDeploymentArtifactExternalAPI(component, deploymentArtifacts.get(responseArtifact.getArtifactLabel()), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentTypeEnum);
 375                 return component;
 376         }
 377
 378         /**
 379          * according lifecycle state of component get updated component details
 380          * @param chosenLifeCycleState
 381          * @param component
 382          * @return
 383          * @throws Exception
 384          */
 385         public Component updateComponentDetailsByLifeCycleState(LifeCycleStatesEnum chosenLifeCycleState, Component component) throws Exception {
 386                 if(LifeCycleStatesEnum.CHECKOUT.equals(chosenLifeCycleState)){
 387                         component = AtomicOperationUtils.getComponentObject(component, UserRoleEnum.DESIGNER);
 388                 }else{
 389                         component = getNewerVersionOfComponent(component, chosenLifeCycleState);
 390                 }
 391                 return component;
 392         }
 393
 394         // Upload artifact via external API + Check auditing for upload operation + Check response of external API
 395         public RestResponse uploadArtifactOfRIIncludingValiditionOfAuditAndResponseCode(Component component, ComponentInstance componentInstance, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, Integer expectedResponseCode) throws Exception {
 396                 RestResponse restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfComponentInstanceOnAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, component.getComponentInstances().get(0));
 397
 398                 // Check response of external API
 399                 Integer responseCode = restResponse.getErrorCode();
 400                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
 401
 402
 403                 // Check auditing for upload operation
 404                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
 405
 406                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
 407
 408                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 409                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
 410
 411                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
 412                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, component);
 413                 expectedExternalAudit.setRESOURCE_NAME(componentInstance.getNormalizedName());
 414                 expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + component.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts");
 415                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
 416
 417                 return restResponse;
 418         }
 419
 420
 421         protected Component getComponentWithResourceInstanceInTargetLifeCycleState(LifeCycleStatesEnum lifeCycleStatesEnum, ResourceTypeEnum resourceTypeEnum) throws Exception {
 422                 Component component;
 423                 if(resourceTypeEnum == ResourceTypeEnum.VF) {
 424                         component = getComponentInTargetLifeCycleState(ComponentTypeEnum.SERVICE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
 425
 426                         Component resourceInstanceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.getValue(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, null);
 427                         AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceInstanceDetails, component, UserRoleEnum.DESIGNER, true).left().value();
 428
 429                         // Add artifact to service if asked for certification request - must be at least one artifact for the flow
 430 //                      if((LifeCycleStatesEnum.CERTIFICATIONREQUEST == lifeCycleStatesEnum) || (LifeCycleStatesEnum.STARTCERTIFICATION == lifeCycleStatesEnum)) {
 431 //                      }
 432                         AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.OTHER, component, UserRoleEnum.DESIGNER, true, true).left().value();
 433                         component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, lifeCycleStatesEnum, true).getLeft();
 434                 } else {
 435                         component = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
 436                         Component resourceInstanceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.getValue(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, resourceTypeEnum);
 437                         AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceInstanceDetails, component, UserRoleEnum.DESIGNER, true).left().value();
 438                         component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, lifeCycleStatesEnum, true).getLeft();
 439                 }
 440
 441
 442                 return component;
 443         }
 444
 445
 446
 447
 448         // Upload artifact via external API + Check auditing for upload operation + Check response of external API
 449         protected RestResponse uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, Integer expectedResponseCode) throws Exception {
 450                 RestResponse restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(component, sdncModifierDetails, artifactReqDetails);
 451
 452                 // Check response of external API
 453                 Integer responseCode = restResponse.getErrorCode();
 454                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
 455
 456
 457                 // Check auditing for upload operation
 458                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
 459
 460                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
 461
 462                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 463                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
 464
 465                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
 466                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, component);
 467                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
 468
 469                 return restResponse;
 470         }
 471
 472
 473
 474         // Check Component version (increase by one if not in checkout)
 475         // Input: component, componentLifeCycleState
 476         // for any LifeCycleState != checkout
 477         // find component of version +0.1
 478         // check that this version different for input version
 479         // check that this component uniqueID different from input uniqueID
 480         // Return: that version
 481         protected synchronized Component getNewerVersionOfComponent(Component component, LifeCycleStatesEnum lifeCycleStatesEnum) throws Exception {
 482                 Component resourceDetails = null;
 483
 484                 if((!lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKOUT)) && (!lifeCycleStatesEnum.equals(LifeCycleStatesEnum.STARTCERTIFICATION))) {
 485
 486
 487                         String resourceVersion = component.getVersion();
 488                         String resourceUniqueID = component.getUniqueId();
 489
 490                         if(component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
 491                                 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), String.format("%.1f", Double.parseDouble(component.getVersion()) + 0.1));
 492                         } else {
 493                                 resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), String.format("%.1f", Double.parseDouble(component.getVersion()) + 0.1));
 494                         }
 495
 496                         String resourceNewVersion = resourceDetails.getVersion();
 497                         String resourceNewUniqueID = resourceDetails.getUniqueId();
 498
 499                         System.out.println(resourceNewVersion);
 500                         System.out.println("Service UUID: " + resourceDetails.getUUID());
 501                         System.out.println("Service UniqueID: " + resourceDetails.getUniqueId());
 502
 503                         // Checking that new version exist + different from old one by unique id
 504                         Assert.assertNotEquals(resourceVersion, resourceNewVersion, "Expected for different resource version.");
 505                         Assert.assertNotEquals(resourceUniqueID, resourceNewUniqueID, "Expected that resource will have new unique ID.");
 506                 } else {
 507                         if(component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
 508                                 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
 509                         } else {
 510                                 resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
 511                         }
 512                 }
 513                 return resourceDetails;
 514         }
 515
 516
 517
 518
 519
 520         // download deployment via external api + check response code for success (200) + get artifactReqDetails and verify payload + verify audit
 521         protected RestResponse downloadResourceDeploymentArtifactExternalAPI(Component component, ArtifactDefinition artifactDefinition, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, ComponentTypeEnum componentTypeEnum) throws Exception {
 522                 RestResponse restResponse;
 523
 524                 if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
 525                         restResponse = ArtifactRestUtils.getComponentInstanceDeploymentArtifactExternalAPI(component.getUUID(), component.getComponentInstances().get(0).getNormalizedName(), artifactDefinition.getArtifactUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), component.getComponentType().toString());
 526                 } else {
 527                         restResponse = ArtifactRestUtils.getResourceDeploymentArtifactExternalAPI(component.getUUID(), artifactDefinition.getArtifactUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), component.getComponentType().toString());
 528                 }
 529
 530                 Integer responseCode = restResponse.getErrorCode();
 531                 Integer expectedCode = 200;
 532                 Assert.assertEquals(responseCode,expectedCode, "Response code is not correct.");
 533
 534
 535                 // For known artifact/payload - verify payload of downloaded artifact
 536                 if (artifactReqDetails != null) {
 537                         String response = restResponse.getResponse();
 538                         String payloadData = artifactReqDetails.getPayload();
 539                         String decodedPaypload = org.openecomp.sdc.ci.tests.utils.Decoder.decode(payloadData);
 540
 541                         Assert.assertEquals(response, decodedPaypload, "Response artifact payload not correct.");
 542                 }
 543
 544                 //TODO - including body - resourceDetails.getName()
 545 //              // Verify audit
 546 //              String auditAction = "DownloadArtifact";
 547 //
 548 //              Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 549 //              body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
 550 //              body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
 551 //
 552 //              ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = new ExpectedResourceAuditJavaObject();
 553 //              expectedResourceAuditJavaObject.setAction(auditAction);
 554 //              expectedResourceAuditJavaObject.setResourceType(resourceDetails.getComponentType().getValue());
 555 //              expectedResourceAuditJavaObject.setStatus("200");
 556 //              expectedResourceAuditJavaObject.setDesc("OK");
 557 //              expectedResourceAuditJavaObject.setCONSUMER_ID("ci");
 558 //
 559 //              if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
 560 //                      expectedResourceAuditJavaObject.setResourceName(resourceDetails.getComponentInstances().get(0).getName());
 561 //                      String resource_url = String.format("/sdc/v1/catalog/services/%s/resourceInstances/%s/artifacts/%s", resourceDetails.getUUID(), resourceDetails.getComponentInstances().get(0).getNormalizedName(), artifactDefinition.getArtifactUUID());
 562 //                      expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
 563 //
 564 //                      AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
 565 //              } else {
 566 //                      expectedResourceAuditJavaObject.setResourceName(resourceDetails.getName());
 567 //                      String resource_url = String.format("/sdc/v1/catalog/services/%s/artifacts/%s", resourceDetails.getUUID(), artifactDefinition.getArtifactUUID());
 568 //                      expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
 569 //              }
 570 //
 571 //              AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
 572
 573                 return restResponse;
 574
 575         }
 576
 577         // download deployment via external api + check response code for success (200) + verify audit
 578         protected void downloadResourceDeploymentArtifactExternalAPI(Component component, ArtifactDefinition artifactDefinition, User sdncModifierDetails) throws Exception {
 579                 downloadResourceDeploymentArtifactExternalAPI(component, artifactDefinition, sdncModifierDetails, null, component.getComponentType());
 580         }
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590         @DataProvider(name="uploadArtifactOnRIViaExternalAPI", parallel=true)
 591         public static Object[][] dataProviderUploadArtifactOnRIViaExternalAPI() {
 592                 return new Object[][] {
 593                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
 594                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON"},
 595                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY"},
 596                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC"},
 597                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT"},
 598                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT"},
 599                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL"},
 600                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP"},
 601
 602
 603                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
 604                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON"},
 605                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY"},
 606                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC"},
 607                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT"},
 608                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT"},
 609                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL"},
 610                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP"},
 611
 612                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA"},
 613                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON"},
 614                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY"},
 615                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC"},
 616                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT"},
 617                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT"},
 618                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL"},
 619                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP"}
 620
 621                         };
 622         }
 623
 624
 625
 626
 627
 628         @Test(dataProvider="uploadArtifactOnRIViaExternalAPI")
 629         public void uploadArtifactOnRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
 630                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 631                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState, artifactType, null);
 632         }
 633
 634
 635
 636         @DataProvider(name="uploadArtifactOnVfcVlCpRIViaExternalAPI", parallel=true)
 637         public static Object[][] dataProviderUploadArtifactOnVfcVlCpRIViaExternalAPI() {
 638                 return new Object[][] {
 639                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
 640                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
 641                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
 642                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
 643                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
 644                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
 645                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
 646                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
 647
 648
 649                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
 650                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
 651                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
 652                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
 653                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
 654                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
 655                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
 656                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
 657
 658                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
 659                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
 660                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
 661                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
 662                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
 663                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
 664                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
 665                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
 666
 667
 668                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
 669                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
 670                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
 671                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
 672                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
 673                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
 674                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
 675                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
 676
 677                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
 678                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
 679                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
 680                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
 681                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
 682                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
 683                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
 684                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
 685
 686                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
 687                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
 688                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
 689                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
 690                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
 691                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
 692                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
 693                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
 694
 695                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
 696                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
 697                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
 698                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
 699                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
 700                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
 701                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
 702                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
 703
 704                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
 705                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
 706                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
 707                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
 708                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
 709                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
 710                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
 711                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
 712
 713                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
 714                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
 715                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
 716                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
 717                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
 718                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
 719                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
 720                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
 721
 722                         };
 723         }
 724
 725
 726
 727
 728
 729         @Test(dataProvider="uploadArtifactOnVfcVlCpRIViaExternalAPI")
 730         public void uploadArtifactOnVfcVlCpRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
 731                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 732                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState, artifactType, resourceTypeEnum);
 733         }
 734
 735
 736
 737
 738         @DataProvider(name="uploadInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI", parallel=true)
 739         public static Object[][] dataProviderUploadInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI() {
 740                 return new Object[][] {
 741
 742                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidTypeToLong"},
 743                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidTypeToLong"},
 744                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidTypeToLong"},
 745                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidTypeToLong"},
 746                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidTypeToLong"},
 747                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidTypeToLong"},
 748                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidTypeToLong"},
 749                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidTypeToLong"},
 750                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidTypeToLong"},
 751
 752                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidTypeEmpty"},
 753                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidTypeEmpty"},
 754                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidTypeEmpty"},
 755                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidTypeEmpty"},
 756                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidTypeEmpty"},
 757                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidTypeEmpty"},
 758                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidTypeEmpty"},
 759                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidTypeEmpty"},
 760                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidTypeEmpty"},
 761
 762                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidNameToLong"},
 763                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidNameToLong"},
 764                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidNameToLong"},
 765                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidNameToLong"},
 766                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidNameToLong"},
 767                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidNameToLong"},
 768                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidNameToLong"},
 769                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidNameToLong"},
 770                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidNameToLong"},
 771
 772                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidNameEmpty"},
 773                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidNameEmpty"},
 774                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidNameEmpty"},
 775                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidNameEmpty"},
 776                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidNameEmpty"},
 777                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidNameEmpty"},
 778                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidNameEmpty"},
 779                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidNameEmpty"},
 780                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidNameEmpty"},
 781
 782                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidLabelToLong"},
 783                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidLabelToLong"},
 784                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidLabelToLong"},
 785                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidLabelToLong"},
 786                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidLabelToLong"},
 787                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidLabelToLong"},
 788                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidLabelToLong"},
 789                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidLabelToLong"},
 790                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidLabelToLong"},
 791
 792                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidLabelEmpty"},
 793                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidLabelEmpty"},
 794                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidLabelEmpty"},
 795                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidLabelEmpty"},
 796                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidLabelEmpty"},
 797                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidLabelEmpty"},
 798                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidLabelEmpty"},
 799                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidLabelEmpty"},
 800                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidLabelEmpty"},
 801
 802                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidDescriptionToLong"},
 803                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidDescriptionToLong"},
 804                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidDescriptionToLong"},
 805                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidDescriptionToLong"},
 806                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidDescriptionToLong"},
 807                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidDescriptionToLong"},
 808                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidDescriptionToLong"},
 809                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidDescriptionToLong"},
 810                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidDescriptionToLong"},
 811
 812                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidDescriptionEmpty"},
 813                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidDescriptionEmpty"},
 814                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidDescriptionEmpty"},
 815                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidDescriptionEmpty"},
 816                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidDescriptionEmpty"},
 817                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidDescriptionEmpty"},
 818                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidDescriptionEmpty"},
 819                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidDescriptionEmpty"},
 820                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidDescriptionEmpty"},
 821
 822                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithSameLabel"},
 823                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithSameLabel"},
 824                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithSameLabel"},
 825                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithSameLabel"},
 826                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithSameLabel"},
 827                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithSameLabel"},
 828                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithSameLabel"},
 829                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithSameLabel"},
 830                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithSameLabel"},
 831
 832                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidCheckSum"},
 833                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidCheckSum"},
 834                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidCheckSum"},
 835                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidCheckSum"},
 836                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidCheckSum"},
 837                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidCheckSum"},
 838                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "uploadArtifactWithInvalidCheckSum"},
 839                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "uploadArtifactWithInvalidCheckSum"},
 840                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "uploadArtifactWithInvalidCheckSum"},
 841                         };
 842         }
 843
 844
 845
 846
 847         // InvalidArtifact + check audit & response code function
 848         @Test(dataProvider="uploadInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI")
 849         public void uploadInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState,
 850                         ComponentTypeEnum componentTypeEnum, String uploadArtifactTestType) throws Exception {
 851                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, componentTypeEnum: %s, uploadArtifactTestType: %s", chosenLifeCycleState, componentTypeEnum, uploadArtifactTestType));
 852                 Component resourceDetails;
 853                 ComponentInstance componentResourceInstanceDetails = null;
 854                 ArtifactReqDetails artifactReqDetails;
 855
 856                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum)     {
 857                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
 858
 859                         resourceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.SERVICE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
 860                         resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(chosenLifeCycleState, null);
 861                         componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
 862                 } else {
 863                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.OTHER.toString(), true, false);
 864
 865                         resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, chosenLifeCycleState, null);
 866                 }
 867
 868
 869                 switch (uploadArtifactTestType) {
 870                 case "uploadArtifactWithInvalidTypeToLong":
 871                         uploadArtifactWithInvalidTypeToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 872                         break;
 873                 case "uploadArtifactWithInvalidTypeEmpty":
 874                         uploadArtifactWithInvalidTypeEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 875                         break;
 876                 case "uploadArtifactWithInvalidCheckSum":
 877                         uploadArtifactWithInvalidCheckSum(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 878                         break;
 879                 case "uploadArtifactWithInvalidNameToLong":
 880                         uploadArtifactWithInvalidNameToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 881                         break;
 882                 case "uploadArtifactWithInvalidNameEmpty":
 883                         uploadArtifactWithInvalidNameEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 884                         break;
 885                 case "uploadArtifactWithInvalidLabelToLong":
 886                         uploadArtifactWithInvalidLabelToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 887                         break;
 888                 case "uploadArtifactWithInvalidLabelEmpty":
 889                         uploadArtifactWithInvalidLabelEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 890                         break;
 891                 case "uploadArtifactWithInvalidDescriptionToLong":
 892                         uploadArtifactWithInvalidDescriptionToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 893                         break;
 894                 case "uploadArtifactWithInvalidDescriptionEmpty":
 895                         uploadArtifactWithInvalidDescriptionEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 896                         break;
 897                 case "uploadArtifactWithSameLabel":
 898                 default:
 899                         uploadArtifactWithSameLabel(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
 900                         break;
 901                 }
 902         }
 903
 904         // Upload artifact with invalid type via external API - to long type
 905         protected void uploadArtifactWithInvalidTypeToLong(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 906                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 907                 artifactReqDetails.setArtifactType("dsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfdsdsfdsfds");
 908                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED.name());
 909                 List<String> variables = asList(artifactReqDetails.getArtifactType());
 910
 911                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 912                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
 913         }
 914
 915         // Upload artifact with invalid type via external API - empty type
 916         protected void uploadArtifactWithInvalidTypeEmpty(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 917                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 918                 artifactReqDetails.setArtifactType("");
 919                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED.name());
 920                 List<String> variables = asList(artifactReqDetails.getArtifactType());
 921
 922                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 923                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
 924         }
 925
 926         // Upload artifact with invalid checksum via external API
 927         protected void uploadArtifactWithInvalidCheckSum(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 928                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 929                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_INVALID_MD5.name());
 930                 List<String> variables = asList();
 931                 uploadArtifactWithInvalidCheckSumOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 932                                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables);
 933         }
 934
 935
 936         // Upload artifact with valid type & invalid name via external API - name to long
 937         protected void uploadArtifactWithInvalidNameToLong(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 938                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 939                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.EXCEEDS_LIMIT.name());
 940                 List<String> variables = asList("artifact name", "255");
 941                 artifactReqDetails.setArtifactName("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
 942                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 943                                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
 944         }
 945
 946
 947         // Upload artifact with valid type & invalid name via external API - name is empty
 948         protected void uploadArtifactWithInvalidNameEmpty(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 949                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 950                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_ARTIFACT_NAME.name());
 951                 List<String> variables = asList();
 952
 953                 artifactReqDetails.setArtifactName("");
 954                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 955                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
 956         }
 957
 958
 959         // Upload artifact with valid type & invalid label via external API - label to long
 960         protected void uploadArtifactWithInvalidLabelToLong(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 961                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 962
 963                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.EXCEEDS_LIMIT.name());
 964                 List<String> variables = asList("artifact label", "255");
 965                 artifactReqDetails.setArtifactLabel("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
 966                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 967                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
 968         }
 969
 970
 971         // Upload artifact with valid type & invalid label via external API - label is empty
 972         protected void uploadArtifactWithInvalidLabelEmpty(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 973                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 974
 975                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 976                 List<String> variables = asList("artifact label");
 977                 artifactReqDetails.setArtifactLabel("");
 978                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 979                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
 980         }
 981
 982
 983         // Upload artifact with invalid description via external API - to long description
 984         protected void uploadArtifactWithInvalidDescriptionToLong(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 985                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 986
 987                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.EXCEEDS_LIMIT.name());
 988                 List<String> variables = asList("artifact description", "256");
 989                 artifactReqDetails.setDescription("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
 990                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 991                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
 992         }
 993
 994
 995         // Upload artifact with invalid description via external API - empty description
 996         protected void uploadArtifactWithInvalidDescriptionEmpty(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
 997                         ComponentInstance componentResourceInstanceDetails) throws Exception {
 998
 999                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
1000                 List<String> variables = asList("artifact description");
1001                 artifactReqDetails.setDescription("");
1002                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1003                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
1004         }
1005
1006
1007
1008
1009         // Upload artifact with same label via external API
1010         protected void uploadArtifactWithSameLabel(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
1011                         ComponentInstance componentResourceInstanceDetails) throws Exception {
1012
1013                 RestResponse restResponse = null;
1014                 if(componentResourceInstanceDetails != null) {
1015                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfComponentInstanceOnAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
1016                 } else {
1017                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails);
1018
1019                 }
1020
1021                 ArtifactDefinition artifactDefinition = getArtifactDataFromJson(restResponse.getResponse());
1022                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_EXIST.name());
1023
1024                 List<String> variables = asList(artifactDefinition.getArtifactDisplayName());
1025                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1026                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
1027         }
1028
1029         protected RestResponse uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
1030                         Integer expectedResponseCode, ComponentInstance componentResourceInstanceDetails, ErrorInfo errorInfo, List<String> variables, LifeCycleStatesEnum lifeCycleStatesEnum, Boolean includeResourceNameInAudit) throws Exception {
1031                 RestResponse restResponse;
1032
1033                 if(componentResourceInstanceDetails != null) {
1034                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfComponentInstanceOnAsset(component, sdncModifierDetails, artifactReqDetails, componentResourceInstanceDetails);
1035                 } else {
1036                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(component, sdncModifierDetails, artifactReqDetails);
1037
1038                 }
1039
1040                 // validate response code
1041                 Integer responseCode = restResponse.getErrorCode();
1042                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
1043
1044                 // Check auditing for upload operation
1045                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
1046
1047                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
1048
1049                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
1050 //              ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
1051
1052                 responseArtifact.setUpdaterFullName("");
1053                 responseArtifact.setUserIdLastUpdater(sdncModifierDetails.getUserId());
1054                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditFailure(assetTypeEnum, action, responseArtifact, component.getUUID(), errorInfo, variables);
1055                 expectedExternalAudit.setRESOURCE_NAME(component.getName());
1056                 expectedExternalAudit.setRESOURCE_TYPE(component.getComponentType().getValue());
1057                 expectedExternalAudit.setARTIFACT_DATA(null);
1058                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
1059                 body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
1060                 if(componentResourceInstanceDetails != null) {
1061                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getComponentInstances().get(0).getNormalizedName());
1062                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + component.getUUID() + "/resourceInstances/" + component.getComponentInstances().get(0).getNormalizedName() + "/artifacts");
1063                         expectedExternalAudit.setRESOURCE_NAME(component.getComponentInstances().get(0).getNormalizedName());
1064                 } else {
1065                         if(includeResourceNameInAudit) {
1066                                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
1067                         } else {
1068                                 if((lifeCycleStatesEnum == LifeCycleStatesEnum.CHECKIN) || (lifeCycleStatesEnum == LifeCycleStatesEnum.STARTCERTIFICATION)) {
1069                                 expectedExternalAudit.setRESOURCE_NAME("");
1070                                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, "");
1071                                 } else {
1072                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
1073                                 }
1074                         }
1075                 }
1076
1077                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
1078
1079                 return restResponse;
1080
1081         }
1082
1083
1084
1085
1086
1087
1088         protected RestResponse uploadArtifactWithInvalidCheckSumOfAssetIncludingValiditionOfAuditAndResponseCode(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
1089                         Integer expectedResponseCode, ComponentInstance componentResourceInstanceDetails, ErrorInfo errorInfo, List<String> variables) throws Exception {
1090                 RestResponse restResponse;
1091
1092                 if(componentResourceInstanceDetails != null) {
1093                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactWithInvalidCheckSumOfComponentInstanceOnAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
1094                 } else {
1095                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactWithInvalidCheckSumOfTheAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails);
1096
1097                 }
1098
1099                 // validate response code
1100                 Integer responseCode = restResponse.getErrorCode();
1101                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
1102
1103                 // Check auditing for upload operation
1104 //              ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.DEPLOYMENT_ARTIFACT_NAME_ALREADY_EXISTS.name());
1105 //               = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.EXCEEDS_LIMIT.name());
1106 //              List<String> variables = asList("artifact name", "255");
1107
1108                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
1109
1110                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
1111
1112                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
1113 //              ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
1114
1115                 responseArtifact.setUpdaterFullName("");
1116                 responseArtifact.setUserIdLastUpdater(sdncModifierDetails.getUserId());
1117                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditFailure(assetTypeEnum, action, responseArtifact, component.getUUID(), errorInfo, variables);
1118                 expectedExternalAudit.setRESOURCE_NAME(component.getName());
1119                 expectedExternalAudit.setRESOURCE_TYPE(component.getComponentType().getValue());
1120                 expectedExternalAudit.setARTIFACT_DATA(null);
1121                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
1122                 body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
1123                 if(componentResourceInstanceDetails != null) {
1124                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getComponentInstances().get(0).getNormalizedName());
1125                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + component.getUUID() + "/resourceInstances/" + component.getComponentInstances().get(0).getNormalizedName() + "/artifacts");
1126                         expectedExternalAudit.setRESOURCE_NAME(component.getComponentInstances().get(0).getNormalizedName());
1127                 } else {
1128                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
1129                 }
1130                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
1131
1132                 return restResponse;
1133
1134         }
1135
1136
1137
1138
1139
1140
1141
1142
1143         @DataProvider(name="uploadArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset", parallel=true)
1144         public static Object[][] dataProviderUploadArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset() {
1145                 return new Object[][] {
1146                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT},
1147                         {ComponentTypeEnum.SERVICE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT},
1148                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT},
1149                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT},
1150                         {ComponentTypeEnum.SERVICE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT},
1151                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT},
1152
1153                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN},
1154                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN},
1155                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN},
1156                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT},
1157                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT},
1158                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT},
1159
1160                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN},
1161                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN},
1162                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN},
1163                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT},
1164                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT},
1165                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT},
1166
1167                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN},
1168                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN},
1169                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN},
1170                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT},
1171                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT},
1172                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT},
1173
1174                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN},
1175                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN},
1176                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN},
1177                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT},
1178                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT},
1179                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT},
1180
1181                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN},
1182                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN},
1183                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN},
1184                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT},
1185                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT},
1186                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT},
1187                         };
1188         }
1189
1190
1191         // External API
1192         // Upload artifact by diffrent user then creator of asset - Fail
1193         @Test(dataProvider="uploadArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset")
1194         public void uploadArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset(ComponentTypeEnum componentTypeEnum, UserRoleEnum userRoleEnum, LifeCycleStatesEnum lifeCycleStatesEnum) throws Exception {
1195                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, userRoleEnum: %s, lifeCycleStatesEnum: %s", componentTypeEnum, userRoleEnum, lifeCycleStatesEnum));
1196                 Component resourceDetails;
1197                 ComponentInstance componentResourceInstanceDetails = null;
1198                 ArtifactReqDetails artifactReqDetails;
1199
1200                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum)     {
1201                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
1202
1203                         resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(lifeCycleStatesEnum, null);
1204                         componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
1205                 } else {
1206                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.OTHER.toString(), true, false);
1207
1208                         resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, lifeCycleStatesEnum, null);
1209                 }
1210
1211                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
1212                 List<String> variables = asList();
1213
1214                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(userRoleEnum),
1215                                 artifactReqDetails, 409, componentResourceInstanceDetails, errorInfo, variables, lifeCycleStatesEnum, true);
1216
1217 //              if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKIN)) {
1218 //                      performeClean();
1219 //              }
1220         }
1221
1222
1223
1224
1225
1226         @DataProvider(name="uploadArtifactOnAssetWhichNotExist", parallel=true)
1227         public static Object[][] dataProviderUploadArtifactOnAssetWhichNotExist() {
1228                 return new Object[][] {
1229                         {ComponentTypeEnum.SERVICE},
1230                         {ComponentTypeEnum.RESOURCE},
1231                         {ComponentTypeEnum.RESOURCE_INSTANCE},
1232                         };
1233         }
1234
1235
1236         // External API
1237         // Upload artifact on VF via external API - happy flow
1238         @Test(dataProvider="uploadArtifactOnAssetWhichNotExist")
1239         public void uploadArtifactOnAssetWhichNotExist(ComponentTypeEnum componentTypeEnum) throws Exception {
1240                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s", componentTypeEnum));
1241                 Component resourceDetails;
1242                 ComponentInstance componentResourceInstanceDetails = null;
1243                 ArtifactReqDetails artifactReqDetails;
1244
1245                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum)     {
1246                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
1247
1248                         resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(LifeCycleStatesEnum.CHECKIN, null);
1249                         componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
1250
1251                         resourceDetails.setUUID("12345");
1252                         componentResourceInstanceDetails.setNormalizedName("12345");
1253                 } else {
1254                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", "OTHER", true, false);
1255
1256                         resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, null);
1257
1258                         resourceDetails.setUUID("12345");
1259                 }
1260
1261                 String componentTypeError = ActionStatus.RESOURCE_NOT_FOUND.name();
1262                 if (ComponentTypeEnum.SERVICE == componentTypeEnum){
1263                         componentTypeError = ActionStatus.SERVICE_NOT_FOUND.name();
1264                 }
1265                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(componentTypeError);
1266                 List<String> variables = asList(resourceDetails.getUUID());
1267
1268                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1269                                 artifactReqDetails, 404, componentResourceInstanceDetails, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, false);
1270
1271 //              performeClean();
1272
1273         }
1274
1275
1276         @DataProvider(name="uploadArtifactOnAssetWhichInInvalidStateForUploading", parallel=true)
1277         public static Object[][] dataProviderUploadArtifactOnAssetWhichInInvalidStateForUploading() {
1278                 return new Object[][] {
1279                         {ComponentTypeEnum.SERVICE},
1280                         {ComponentTypeEnum.RESOURCE},
1281                         {ComponentTypeEnum.RESOURCE_INSTANCE},
1282                         };
1283         }
1284
1285
1286         @Test(dataProvider="uploadArtifactOnAssetWhichInInvalidStateForUploading")
1287         public void uploadArtifactOnAssetWhichInInvalidStateForUploading(ComponentTypeEnum componentTypeEnum) throws Exception {
1288                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s", componentTypeEnum));
1289                 Component resourceDetails;
1290                 ComponentInstance componentResourceInstanceDetails = null;
1291                 ArtifactReqDetails artifactReqDetails;
1292
1293                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum)     {
1294                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
1295
1296                         resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(LifeCycleStatesEnum.STARTCERTIFICATION, null);
1297                         componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
1298                 } else {
1299                         artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.OTHER.toString(), true, false);
1300
1301                         resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.STARTCERTIFICATION, null);
1302                 }
1303
1304                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name());
1305                 List<String> variables = asList(resourceDetails.getName(), resourceDetails.getComponentType().toString().toLowerCase(), resourceDetails.getLastUpdaterFullName().split(" ")[0],
1306                                 resourceDetails.getLastUpdaterFullName().split(" ")[1], resourceDetails.getLastUpdaterUserId());
1307
1308                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1309                                 artifactReqDetails, 403, componentResourceInstanceDetails, errorInfo, variables, LifeCycleStatesEnum.STARTCERTIFICATION, true);
1310         }
1311
1312
1313         ////////////////////////////////////////////////////////////////////////////////////
1314         ////////////////////////////////////////////////////////////////////////////////////
1315         ////////////////////////////////////////////////////////////////////////////////////
1316         //                                      Update External API                                                                                       //
1317         ////////////////////////////////////////////////////////////////////////////////////
1318         ////////////////////////////////////////////////////////////////////////////////////
1319         ////////////////////////////////////////////////////////////////////////////////////
1320
1321         @DataProvider(name="updateArtifactForServiceViaExternalAPI", parallel=true)
1322         public static Object[][] dataProviderUpdateArtifactForServiceViaExternalAPI() {
1323                 return new Object[][] {
1324                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
1325                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
1326                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
1327                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
1328                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1329                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
1330                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
1331                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
1332                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
1333                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
1334                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
1335                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
1336                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
1337                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
1338                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"},
1339                         {LifeCycleStatesEnum.CERTIFY, "YANG_XML"},
1340                         {LifeCycleStatesEnum.CERTIFY, "VNF_CATALOG"},
1341                         {LifeCycleStatesEnum.CERTIFY, "MODEL_INVENTORY_PROFILE"},
1342                         {LifeCycleStatesEnum.CERTIFY, "MODEL_QUERY_SPEC"},
1343                         {LifeCycleStatesEnum.CERTIFY, "OTHER"}
1344                         };
1345         }
1346
1347
1348
1349
1350         // Update artifact for Service - Success
1351         @Test(dataProvider="updateArtifactForServiceViaExternalAPI")
1352         public void updateArtifactForServiceViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
1353                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s", lifeCycleStatesEnum, artifactType));
1354                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.SERVICE, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
1355                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.SERVICE, lifeCycleStatesEnum, artifactType);
1356
1357                 // for certify version check that previous version exist, and that it artifact can be download + checksum
1358                 if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CERTIFY)) {
1359                         // Download the uploaded artifact via external API
1360                         downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(component, artifactType, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ComponentTypeEnum.SERVICE);
1361                 }
1362         }
1363
1364         @DataProvider(name="updateArtifactForVFViaExternalAPI", parallel=true)
1365         public static Object[][] dataProviderUpdateArtifactForVFViaExternalAPI() {
1366                 return new Object[][] {
1367                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_JSON"},
1368                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_POLICY"},
1369                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_EVENT"},
1370                         {LifeCycleStatesEnum.CHECKOUT, "APPC_CONFIG"},
1371                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_DOC"},
1372                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_TOSCA"},
1373                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
1374                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
1375                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE"},
1376                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE"},
1377                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
1378                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
1379                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1380
1381                         {LifeCycleStatesEnum.CHECKIN, "DCAE_JSON"},
1382                         {LifeCycleStatesEnum.CHECKIN, "DCAE_POLICY"},
1383                         {LifeCycleStatesEnum.CHECKIN, "DCAE_EVENT"},
1384                         {LifeCycleStatesEnum.CHECKIN, "APPC_CONFIG"},
1385                         {LifeCycleStatesEnum.CHECKIN, "DCAE_DOC"},
1386                         {LifeCycleStatesEnum.CHECKIN, "DCAE_TOSCA"},
1387                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
1388                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
1389                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE"},
1390                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE"},
1391                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
1392                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
1393                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
1394
1395                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_JSON"},
1396                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_POLICY"},
1397                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_EVENT"},
1398                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "APPC_CONFIG"},
1399                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_DOC"},
1400                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_TOSCA"},
1401                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
1402                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
1403                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE"},
1404                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE"},
1405                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
1406                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
1407                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"}
1408                         };
1409         }
1410
1411
1412         // Update artifact for VF - Success
1413         @Test(dataProvider="updateArtifactForVFViaExternalAPI")
1414         public void updateArtifactForVFViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
1415                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s", lifeCycleStatesEnum, artifactType));
1416                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
1417                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE, lifeCycleStatesEnum, artifactType);
1418
1419                 // for certify version check that previous version exist, and that it artifact can be download + checksum
1420                 if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CERTIFY)) {
1421                         // Download the uploaded artifact via external API
1422                         downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(component, artifactType, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ComponentTypeEnum.RESOURCE);
1423                 }
1424         }
1425
1426         @DataProvider(name="updateArtifactForVfcVlCpViaExternalAPI", parallel=true)
1427         public static Object[][] dataProviderUpdateArtifactForVfcVlCpViaExternalAPI() {
1428                 return new Object[][] {
1429                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VFC},
1430                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VFC},
1431                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VFC},
1432                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
1433                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
1434                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
1435                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VFC},
1436                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
1437                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
1438
1439                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VL},
1440                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VL},
1441                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VL},
1442                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VL},
1443                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
1444                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
1445                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VL},
1446                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
1447                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
1448
1449                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.CP},
1450                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.CP},
1451                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.CP},
1452                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.CP},
1453                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
1454                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
1455                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.CP},
1456                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
1457                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
1458
1459                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VFC},
1460                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VFC},
1461                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VFC},
1462                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
1463                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
1464                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
1465                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VFC},
1466                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
1467                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
1468
1469                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VL},
1470                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VL},
1471                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VL},
1472                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VL},
1473                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
1474                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
1475                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VL},
1476                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
1477                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
1478
1479                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.CP},
1480                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.CP},
1481                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.CP},
1482                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.CP},
1483                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
1484                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
1485                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.CP},
1486                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
1487                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
1488
1489                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VFC},
1490                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VFC},
1491                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VFC},
1492                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
1493                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
1494                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
1495                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VFC},
1496                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
1497                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
1498
1499                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VL},
1500                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VL},
1501                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VL},
1502                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VL},
1503                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
1504                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
1505                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VL},
1506                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
1507                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
1508
1509                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.CP},
1510                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.CP},
1511                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.CP},
1512                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.CP},
1513                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
1514                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
1515                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.CP},
1516                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
1517                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
1518                         };
1519         }
1520
1521
1522         // Update artifact for VFC/VL/CP - Success
1523         @Test(dataProvider="updateArtifactForVfcVlCpViaExternalAPI")
1524         public void updateArtifactForVfcVlCpViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
1525                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s, resourceTypeEnum: %s", lifeCycleStatesEnum, artifactType, resourceTypeEnum));
1526                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
1527                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE, lifeCycleStatesEnum, artifactType);
1528
1529                 // for certify version check that previous version exist, and that it artifact can be download + checksum
1530                 if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CERTIFY)) {
1531                         // Download the uploaded artifact via external API
1532                         downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(component, artifactType, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ComponentTypeEnum.RESOURCE);
1533                 }
1534         }
1535
1536         @DataProvider(name="updateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI", parallel=true)
1537         public static Object[][] dataProviderUpdateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI() {
1538                 return new Object[][] {
1539                         {ResourceTypeEnum.VFC},
1540                         {ResourceTypeEnum.VL},
1541                         {ResourceTypeEnum.CP}
1542                         };
1543         }
1544
1545         // Verify that it cannot update VFC/VL/CP artifact on VFCi/VLi/CPi - Failure flow
1546         @Test(dataProvider="updateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI")
1547         public void updateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI(ResourceTypeEnum resourceTypeEnum) throws Exception {
1548                 getExtendTest().log(Status.INFO, String.format("resourceTypeEnum: %s", resourceTypeEnum));
1549
1550                 Component resourceInstanceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.getValue(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, resourceTypeEnum);
1551                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", "SNMP_TRAP", true, false);
1552                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceInstanceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
1553                 resourceInstanceDetails = AtomicOperationUtils.changeComponentState(resourceInstanceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
1554                 Component component = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
1555                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceInstanceDetails, component, UserRoleEnum.DESIGNER, true).left().value();
1556                 component = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
1557
1558                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
1559                 Map<String, ArtifactDefinition> deploymentArtifacts;
1560                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, ComponentTypeEnum.RESOURCE_INSTANCE);
1561                 String artifactUUID = null;
1562                 for (String key : deploymentArtifacts.keySet()) {
1563                         if (key.startsWith("ci") && StringUtils.isNotEmpty(deploymentArtifacts.get(key).getArtifactUUID())) {
1564                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
1565                                 break;
1566                         }
1567                 }
1568                 List<String> variables = asList(artifactUUID);
1569                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", errorInfo, variables, UserRoleEnum.DESIGNER, 404);
1570
1571         }
1572
1573         @DataProvider(name="updateArtifactOnRIViaExternalAPI", parallel=true)
1574         public static Object[][] dataProviderUpdateArtifactOnRIViaExternalAPI() {
1575                 return new Object[][] {
1576                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", null},
1577                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", null},
1578                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", null},
1579                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", null},
1580                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", null},
1581                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", null},
1582
1583                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", null},
1584                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", null},
1585                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", null},
1586                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", null},
1587                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", null},
1588                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", null},
1589
1590                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
1591                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VF},
1592                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VF},
1593                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VF},
1594                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VF},
1595                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VF}
1596
1597                         };
1598         }
1599
1600         @Test(dataProvider="updateArtifactOnRIViaExternalAPI")
1601         public void updateArtifactOnRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
1602                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
1603                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
1604                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState, artifactType);
1605
1606                 // for certify version check that previous version exist, and that it artifact can be download + checksum
1607                 if(chosenLifeCycleState.equals(LifeCycleStatesEnum.CERTIFY)) {
1608                         // Download the uploaded artifact via external API
1609                         downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(component, artifactType, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ComponentTypeEnum.RESOURCE_INSTANCE);
1610                 }
1611         }
1612
1613         @DataProvider(name="updateArtifactOnVfcVlCpRIViaExternalAPI", parallel=true)
1614         public static Object[][] dataProviderUpdateArtifactOnVfcVlCpRIViaExternalAPI() {
1615                 return new Object[][] {
1616                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
1617                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
1618                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
1619                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
1620                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
1621                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
1622                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
1623                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
1624
1625
1626                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
1627                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
1628                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
1629                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
1630                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
1631                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
1632                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
1633                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
1634
1635                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
1636                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
1637                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
1638                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
1639                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
1640                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
1641                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
1642                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
1643
1644
1645                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
1646                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
1647                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
1648                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
1649                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
1650                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
1651                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
1652                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
1653
1654                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
1655                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
1656                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
1657                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
1658                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
1659                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
1660                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
1661                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
1662
1663                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
1664                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
1665                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
1666                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
1667                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
1668                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
1669                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
1670                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
1671
1672                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
1673                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
1674                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
1675                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
1676                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
1677                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
1678                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
1679                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
1680
1681                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
1682                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
1683                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
1684                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
1685                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
1686                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
1687                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
1688                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
1689
1690                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
1691                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
1692                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
1693                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
1694                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
1695                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
1696                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
1697                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
1698
1699                         };
1700         }
1701
1702         @Test(dataProvider="updateArtifactOnVfcVlCpRIViaExternalAPI")
1703         public void updateArtifactOnVfcVlCpRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
1704                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
1705                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
1706                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState, artifactType);
1707
1708
1709                 // for certify version check that previous version exist, and that it artifact can be download + checksum
1710                 if(chosenLifeCycleState.equals(LifeCycleStatesEnum.CERTIFY)) {
1711                         // Download the uploaded artifact via external API
1712                         downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(component, artifactType, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ComponentTypeEnum.RESOURCE_INSTANCE);
1713                 }
1714         }
1715
1716         @DataProvider(name="updateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset", parallel=true)
1717         public static Object[][] dataProviderUpdateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset() {
1718                 return new Object[][] {
1719                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1720                         {ComponentTypeEnum.SERVICE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1721                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1722
1723                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1724                         {ComponentTypeEnum.SERVICE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1725                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1726
1727                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1728                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1729                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1730                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1731                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1732                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1733
1734                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1735                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1736                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1737                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1738                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1739                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1740
1741                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1742                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1743                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1744                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1745                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1746                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1747
1748                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1749                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1750                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1751                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1752                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1753                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1754
1755                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1756                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1757                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1758                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1759                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1760                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1761                         };
1762         }
1763
1764         // External API
1765         // Update artifact by diffrent user then creator of asset - Fail
1766         @Test(dataProvider="updateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset")
1767         public void updateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset(ComponentTypeEnum componentTypeEnum, UserRoleEnum userRoleEnum, LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
1768                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, userRoleEnum: %s, lifeCycleStatesEnum: %s, artifactType: %s", componentTypeEnum, userRoleEnum, lifeCycleStatesEnum, artifactType));
1769                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1770                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
1771                 List<String> variables = asList();
1772                 updateArtifactOnAssetViaExternalAPI(component, componentTypeEnum, lifeCycleStatesEnum, artifactType, errorInfo, variables, userRoleEnum, 409);
1773         }
1774
1775
1776         @DataProvider(name="updateArtifactOnAssetWhichNotExist", parallel=true)
1777         public static Object[][] dataProviderUpdateArtifactOnAssetWhichNotExist() {
1778                 return new Object[][] {
1779                         {ComponentTypeEnum.SERVICE, "OTHER", null},
1780                         {ComponentTypeEnum.RESOURCE, "OTHER", null},
1781                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
1782                         };
1783         }
1784
1785         // External API
1786         // Upload artifact on VF via external API - happy flow
1787         @Test(dataProvider="updateArtifactOnAssetWhichNotExist")
1788         public void updateArtifactOnAssetWhichNotExist(ComponentTypeEnum componentTypeEnum, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
1789                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
1790                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, resourceTypeEnum);
1791
1792                 // get updated artifact data
1793                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
1794                 ArtifactReqDetails artifactReqDetails = getUpdatedArtifact(deploymentArtifacts, artifactType);
1795                 String artifactUUID = deploymentArtifacts.get(artifactReqDetails.getArtifactLabel()).getArtifactUUID();
1796
1797                 // Invalid artifactUUID
1798                 String invalidArtifactUUID = "12341234-1234-1234-1234-123412341234";
1799                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
1800                 List<String> variables = asList(invalidArtifactUUID);
1801
1802                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1803                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1804                                         404, component.getComponentInstances().get(0), artifactReqDetails, invalidArtifactUUID, errorInfo, variables, null, true);
1805                 } else {
1806                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1807                                         404, null, artifactReqDetails, invalidArtifactUUID, errorInfo, variables, null, true);
1808
1809                 }
1810
1811                 // Invalid componentUUID
1812 //              errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
1813 //              variables = asList("null");
1814
1815                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1816                         component.getComponentInstances().get(0).setNormalizedName("invalidNormalizedName");
1817
1818                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER.name());
1819
1820                         variables = asList("invalidNormalizedName", ComponentTypeEnum.RESOURCE_INSTANCE.getValue().toLowerCase(), ComponentTypeEnum.SERVICE.getValue(), component.getName());
1821                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1822                                         404, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, true);
1823                 } else {
1824                         component.setUUID("invalidComponentUUID");
1825
1826                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
1827                         variables = asList("null");
1828
1829                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1830                                         404, null, artifactReqDetails, artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, false);
1831                 }
1832
1833                 performClean();
1834         }
1835
1836
1837         @DataProvider(name="updateArtifactOnAssetWhichInInvalidStateForUploading", parallel=true)
1838         public static Object[][] dataProviderUpdateProviderDeleteArtifactOnAssetWhichInInvalidStateForUploading() {
1839                 return new Object[][] {
1840                         {ComponentTypeEnum.SERVICE, "OTHER"},
1841                         {ComponentTypeEnum.RESOURCE, "OTHER"},
1842                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA"},
1843                         };
1844         }
1845
1846         @Test(dataProvider="updateArtifactOnAssetWhichInInvalidStateForUploading")
1847         public void updateArtifactOnAssetWhichInInvalidStateForUploading(ComponentTypeEnum componentTypeEnum, String artifactType) throws Exception {
1848                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
1849                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1850                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name());
1851                 List<String> variables = asList(component.getName(), component.getComponentType().toString().toLowerCase(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getFirstName(),
1852                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getLastName(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId());
1853                 updateArtifactOnAssetViaExternalAPI(component, componentTypeEnum, LifeCycleStatesEnum.STARTCERTIFICATION, artifactType, errorInfo, variables, UserRoleEnum.DESIGNER, 403);
1854
1855         }
1856
1857
1858
1859
1860
1861         @DataProvider(name="updateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI", parallel=true)
1862         public static Object[][] dataProviderUpdateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI() {
1863                 return new Object[][] {
1864                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidCheckSum"},
1865                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidCheckSum"},
1866                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidCheckSum"},
1867                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidCheckSum"},
1868                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidCheckSum"},
1869                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidCheckSum"},
1870                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidCheckSum"},
1871                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidCheckSum"},
1872                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidCheckSum"},
1873
1874                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameToLong"},
1875                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameToLong"},
1876                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameToLong"},
1877                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameToLong"},
1878                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameToLong"},
1879                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameToLong"},
1880                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameToLong"},
1881                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameToLong"},
1882                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameToLong"},
1883
1884                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameEmpty"},
1885                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameEmpty"},
1886                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameEmpty"},
1887                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameEmpty"},
1888                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameEmpty"},
1889                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameEmpty"},
1890                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameEmpty"},
1891                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameEmpty"},
1892                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameEmpty"},
1893
1894                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelToLong"},
1895                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelToLong"},
1896                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelToLong"},
1897                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelToLong"},
1898                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelToLong"},
1899                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelToLong"},
1900                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelToLong"},
1901                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelToLong"},
1902                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelToLong"},
1903
1904                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelEmpty"},
1905                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelEmpty"},
1906                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelEmpty"},
1907                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelEmpty"},
1908                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelEmpty"},
1909                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelEmpty"},
1910                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelEmpty"},
1911                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelEmpty"},
1912                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelEmpty"},
1913
1914                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionToLong"},
1915                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionToLong"},
1916                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionToLong"},
1917                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionToLong"},
1918                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionToLong"},
1919                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionToLong"},
1920                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionToLong"},
1921                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionToLong"},
1922                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionToLong"},
1923
1924                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionEmpty"},
1925                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionEmpty"},
1926                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionEmpty"},
1927                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionEmpty"},
1928                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionEmpty"},
1929                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionEmpty"},
1930                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionEmpty"},
1931                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionEmpty"},
1932                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionEmpty"},
1933                         };
1934         }
1935
1936
1937
1938
1939         // InvalidArtifact + check audit & response code function
1940         @Test(dataProvider="updateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI")
1941         public void updateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState,
1942                         ComponentTypeEnum componentTypeEnum, String uploadArtifactTestType) throws Exception {
1943                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, componentTypeEnum: %s, uploadArtifactTestType: %s", chosenLifeCycleState, componentTypeEnum, uploadArtifactTestType));
1944                 Component component;
1945                 ComponentInstance componentInstance = null;
1946                 String artifactType;
1947
1948                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum)     {
1949                         artifactType = ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString();
1950                         component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1951                         componentInstance = component.getComponentInstances().get(0);
1952                 } else {
1953                         artifactType = ArtifactTypeEnum.OTHER.toString();
1954                         component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1955                 }
1956
1957                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
1958
1959                 switch (uploadArtifactTestType) {
1960                 case "updateArtifactWithInvalidCheckSum":
1961                         updateArtifactWithInvalidCheckSum(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1962                         break;
1963                 case "updateArtifactWithInvalidNameToLong":
1964                         updateArtifactWithInvalidNameToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1965                         break;
1966                 case "updateArtifactWithInvalidNameEmpty":
1967                         updateArtifactWithInvalidNameEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1968                         break;
1969                 case "updateArtifactWithInvalidLabelToLong":
1970                         updateArtifactWithInvalidLabelToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1971                         break;
1972                 case "updateArtifactWithInvalidLabelEmpty":
1973                         updateArtifactWithInvalidLabelEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1974                         break;
1975                 case "updateArtifactWithInvalidDescriptionToLong":
1976                         updateArtifactWithInvalidDescriptionToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1977                         break;
1978                 case "updateArtifactWithInvalidDescriptionEmpty":
1979                 default:
1980                         updateArtifactWithInvalidDescriptionEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1981                         break;
1982                 }
1983
1984 ///////////////////////////////////////////////////////////////////////////////
1985 //              // TODO: there is defect when checking invalid type
1986 ////            // Upload artifact with invalid type via external API
1987 ////            // invalid type
1988 ////            String artifactType = artifactReqDetails.getArtifactType();
1989 ////            artifactReqDetails.setArtifactType("invalidType");
1990 ////            restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 400, componentResourceInstanceDetails);
1991 ////            // empty type
1992 ////            artifactReqDetails.setArtifactType("");
1993 ////            restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 400, componentResourceInstanceDetails);
1994 ////            artifactReqDetails.setArtifactType(artifactType);
1995 ///////////////////////////////////////////////////////////////////////////////
1996         }
1997
1998         // TODO
1999         // Update artifact with invalid checksum via external API
2000         protected void updateArtifactWithInvalidCheckSum(Component component, User sdncModifierDetails, String artifactType,
2001                         ComponentInstance componentInstance) throws Exception {
2002                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_INVALID_MD5.name());
2003                 List<String> variables = asList();
2004 //              uploadArtifactWithInvalidCheckSumOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2005 //                                              artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables);
2006         }
2007
2008
2009         // Update artifact with valid type & invalid name via external API - name to long
2010         protected void updateArtifactWithInvalidNameToLong(Component component, User sdncModifierDetails, String artifactType,
2011                         ComponentInstance componentInstance) throws Exception {
2012
2013                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2014                 String artifactUUID = null;
2015                 Map<String, ArtifactDefinition> deploymentArtifacts;
2016                 if(componentInstance != null) {
2017                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2018                 } else {
2019                         deploymentArtifacts = component.getDeploymentArtifacts();
2020                 }
2021
2022                 for (String key : deploymentArtifacts.keySet()) {
2023                         if (key.startsWith("ci")) {
2024                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2025                                 break;
2026                         }
2027                 }
2028
2029                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.EXCEEDS_LIMIT.name());
2030                 List<String> variables = asList("artifact name", "255");
2031                 artifactReqDetails.setArtifactName("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2032
2033                 if(componentInstance != null) {
2034                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2035                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2036                 } else {
2037                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2038                                         errorInfo.getCode(), null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2039
2040                 }
2041         }
2042
2043
2044         // Update artifact with valid type & invalid name via external API - name is empty
2045         protected void updateArtifactWithInvalidNameEmpty(Component component, User sdncModifierDetails, String artifactType,
2046                         ComponentInstance componentInstance) throws Exception {
2047
2048                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2049                 String artifactUUID = null;
2050                 Map<String, ArtifactDefinition> deploymentArtifacts;
2051                 if(componentInstance != null) {
2052                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2053                 } else {
2054                         deploymentArtifacts = component.getDeploymentArtifacts();
2055                 }
2056
2057                 for (String key : deploymentArtifacts.keySet()) {
2058                         if (key.startsWith("ci")) {
2059                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2060                                 break;
2061                         }
2062                 }
2063
2064                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_ARTIFACT_NAME.name());
2065                 List<String> variables = asList();
2066                 artifactReqDetails.setArtifactName("");
2067
2068                 if(componentInstance != null) {
2069                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2070                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2071                 } else {
2072                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2073                                         errorInfo.getCode(), null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2074
2075                 }
2076         }
2077
2078
2079         // Update artifact with valid type & invalid label via external API - label to long
2080         protected void updateArtifactWithInvalidLabelToLong(Component component, User sdncModifierDetails, String artifactType,
2081                         ComponentInstance componentInstance) throws Exception {
2082
2083                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2084                 String artifactUUID = null;
2085                 Map<String, ArtifactDefinition> deploymentArtifacts;
2086                 if(componentInstance != null) {
2087                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2088                 } else {
2089                         deploymentArtifacts = component.getDeploymentArtifacts();
2090                 }
2091
2092                 for (String key : deploymentArtifacts.keySet()) {
2093                         if (key.startsWith("ci")) {
2094                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2095                                 break;
2096                         }
2097                 }
2098
2099                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2100                 List<String> variables = asList();
2101                 artifactReqDetails.setArtifactLabel("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2102
2103                 if(componentInstance != null) {
2104                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2105                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2106                 } else {
2107                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2108                                         errorInfo.getCode(), null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2109
2110                 }
2111         }
2112
2113
2114         // Update artifact with valid type & invalid label via external API - label is empty
2115         protected void updateArtifactWithInvalidLabelEmpty(Component component, User sdncModifierDetails, String artifactType,
2116                         ComponentInstance componentInstance) throws Exception {
2117
2118                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2119                 String artifactUUID = null;
2120                 Map<String, ArtifactDefinition> deploymentArtifacts;
2121                 if(componentInstance != null) {
2122                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2123                 } else {
2124                         deploymentArtifacts = component.getDeploymentArtifacts();
2125                 }
2126
2127                 for (String key : deploymentArtifacts.keySet()) {
2128                         if (key.startsWith("ci")) {
2129                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2130                                 break;
2131                         }
2132                 }
2133
2134                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
2135                 List<String> variables = asList("artifact label");
2136                 artifactReqDetails.setArtifactLabel("");
2137
2138                 if(componentInstance != null) {
2139                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2140                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2141                 } else {
2142                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2143                                         errorInfo.getCode(), null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2144
2145                 }
2146         }
2147
2148
2149         // Update artifact with invalid description via external API - to long description
2150         protected void updateArtifactWithInvalidDescriptionToLong(Component component, User sdncModifierDetails, String artifactType,
2151                         ComponentInstance componentInstance) throws Exception {
2152
2153                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2154                 String artifactUUID = null;
2155                 Map<String, ArtifactDefinition> deploymentArtifacts;
2156                 if(componentInstance != null) {
2157                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2158                 } else {
2159                         deploymentArtifacts = component.getDeploymentArtifacts();
2160                 }
2161
2162                 for (String key : deploymentArtifacts.keySet()) {
2163                         if (key.startsWith("ci")) {
2164                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2165                                 break;
2166                         }
2167                 }
2168
2169                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2170                 List<String> variables = asList();
2171                 artifactReqDetails.setDescription("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2172
2173                 if(componentInstance != null) {
2174                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2175                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2176                 } else {
2177                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2178                                         errorInfo.getCode(), null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2179
2180                 }
2181         }
2182
2183
2184         // Update artifact with invalid description via external API - empty description
2185         protected void updateArtifactWithInvalidDescriptionEmpty(Component component, User sdncModifierDetails, String artifactType,
2186                         ComponentInstance componentInstance) throws Exception {
2187
2188                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2189                 String artifactUUID = null;
2190                 Map<String, ArtifactDefinition> deploymentArtifacts;
2191                 if(componentInstance != null) {
2192                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2193                 } else {
2194                         deploymentArtifacts = component.getDeploymentArtifacts();
2195                 }
2196
2197                 for (String key : deploymentArtifacts.keySet()) {
2198                         if (key.startsWith("ci")) {
2199                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2200                                 break;
2201                         }
2202                 }
2203
2204
2205                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2206                 List<String> variables = asList("artifact description");
2207                 artifactReqDetails.setDescription("");
2208
2209                 if(componentInstance != null) {
2210                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2211                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2212                 } else {
2213                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2214                                         errorInfo.getCode(), null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2215
2216                 }
2217         }
2218
2219
2220         // Unhappy flow - get chosen life cycle state, artifact type and asset type
2221         // update artifact via external API + check audit & response code
2222         // Download artifact via external API + check audit & response code
2223         // Check artifact version, uuid & checksusm
2224         protected Component updateArtifactOnAssetViaExternalAPI(Component component, ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ErrorInfo errorInfo, List<String> variables, UserRoleEnum userRoleEnum, Integer expectedResponseCode) throws Exception {
2225                 String componentVersionBeforeUpdate = null;
2226
2227                 // get updated artifact data
2228                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
2229                 componentVersionBeforeUpdate = component.getVersion();
2230
2231                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2232                 ArtifactReqDetails artifactReqDetails = getUpdatedArtifact(deploymentArtifacts, artifactType);
2233
2234                 String artifactName = artifactReqDetails.getArtifactLabel();
2235                 String artifactUUID = deploymentArtifacts.get(artifactName).getArtifactUUID();
2236                 String artifactVersionBeforeUpdate = deploymentArtifacts.get(artifactName).getArtifactVersion();
2237                 int numberOfArtifact = deploymentArtifacts.size();
2238
2239                 // create component/s & upload artifact via external api
2240                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2241                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2242                                         expectedResponseCode, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, chosenLifeCycleState, true);
2243                 } else {
2244                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2245                                         expectedResponseCode, null, artifactReqDetails, artifactUUID, errorInfo, variables, chosenLifeCycleState, true);
2246                 }
2247
2248                 if(component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
2249                         component = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
2250                 } else {
2251                         component = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
2252                 }
2253
2254                 // Get list of deployment artifact + download them via external API
2255                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2256                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2257                 } else {
2258                         deploymentArtifacts = component.getDeploymentArtifacts();
2259                 }
2260                 Assert.assertEquals(numberOfArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will be same as before.");
2261                 Assert.assertEquals(String.valueOf((Integer.parseInt(artifactVersionBeforeUpdate))), deploymentArtifacts.get(artifactName).getArtifactVersion(), "Expected that aftifact will not change.");
2262                 Assert.assertEquals(artifactUUID, deploymentArtifacts.get(artifactName).getArtifactUUID(), "Expected that aftifactUUID will not change.");
2263                 Assert.assertEquals(componentVersionBeforeUpdate, component.getVersion(), "Expected that check-out component will not change version number.");
2264
2265                 return component;
2266         }
2267
2268         protected RestResponse updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component component, User sdncModifierDetails,
2269                         Integer expectedResponseCode, ComponentInstance componentInstance, ArtifactReqDetails artifactReqDetails, String artifactUUID, ErrorInfo errorInfo, List<String> variables, LifeCycleStatesEnum lifeCycleStatesEnum, Boolean resourceNameInAudit) throws Exception {
2270                 RestResponse restResponse;
2271
2272                 if(componentInstance != null) {
2273                         restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfComponentInstanceOnAsset(component, sdncModifierDetails, artifactReqDetails, componentInstance, artifactUUID);
2274                 } else {
2275                         restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfTheAsset(component, sdncModifierDetails, artifactReqDetails, artifactUUID);
2276
2277                 }
2278
2279                 // validate response code
2280                 Integer responseCode = restResponse.getErrorCode();
2281                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2282
2283                 //TODO
2284                 // Check auditing for upload operation
2285                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2286
2287                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2288
2289                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
2290 //              ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
2291
2292                 responseArtifact.setUpdaterFullName("");
2293                 responseArtifact.setUserIdLastUpdater(sdncModifierDetails.getUserId());
2294                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditFailure(assetTypeEnum, action, responseArtifact, component.getUUID(), errorInfo, variables);
2295                 expectedExternalAudit.setRESOURCE_NAME(component.getName());
2296                 expectedExternalAudit.setRESOURCE_TYPE(component.getComponentType().getValue());
2297                 expectedExternalAudit.setARTIFACT_DATA("");
2298                 expectedExternalAudit.setCURR_ARTIFACT_UUID(artifactUUID);
2299                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2300                 body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
2301                 if(componentInstance != null) {
2302                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getComponentInstances().get(0).getNormalizedName());
2303                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + component.getUUID() + "/resourceInstances/" + component.getComponentInstances().get(0).getNormalizedName() + "/artifacts/" + artifactUUID);
2304                         expectedExternalAudit.setRESOURCE_NAME(component.getComponentInstances().get(0).getNormalizedName());
2305                 } else {
2306                         expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL() + "/" + artifactUUID);
2307                         if((lifeCycleStatesEnum == LifeCycleStatesEnum.CHECKIN) || (lifeCycleStatesEnum == LifeCycleStatesEnum.STARTCERTIFICATION)) {
2308                                 if(resourceNameInAudit) {
2309                                         expectedExternalAudit.setRESOURCE_NAME(component.getName());
2310                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
2311                                 } else {
2312                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
2313 //                                      body.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, artifactUUID);
2314                                         expectedExternalAudit.setRESOURCE_NAME("");
2315                                 }
2316                         } else {
2317                                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
2318                         }
2319                 }
2320
2321
2322                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2323                 return restResponse;
2324
2325         }
2326
2327
2328         // This function get component, user & if updatedPayload or not
2329         // It will create default payload / updated payload of artifact
2330         // And download artifact of component which starts with ci
2331         protected RestResponse downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(Component component, String artifactType, User sdncModifierDetails, ComponentTypeEnum componentTypeEnum) throws IOException, Exception {
2332                 // Download the uploaded artifact via external API
2333                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("abcd", artifactType, true, false);
2334                 String artifactName = null;
2335                 for (String key : component.getDeploymentArtifacts().keySet()) {
2336                         if (key.startsWith("ci")) {
2337                                 artifactName = key;
2338                                 break;
2339                         }
2340                 }
2341                 return downloadResourceDeploymentArtifactExternalAPI(component, component.getDeploymentArtifacts().get(artifactName), sdncModifierDetails, artifactReqDetails, componentTypeEnum);
2342         }
2343
2344         // Get deployment artifact of RI
2345         protected Map<String, ArtifactDefinition> getDeploymentArtifactsOfAsset(Component component, ComponentTypeEnum componentTypeEnum) {
2346                 Map<String, ArtifactDefinition> deploymentArtifacts = null;
2347                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2348                         for(ComponentInstance componentInstance: component.getComponentInstances()) {
2349                                 if(componentInstance.getNormalizedName().startsWith("ci")) {
2350                                         deploymentArtifacts = componentInstance.getDeploymentArtifacts();
2351                                         break;
2352                                 }
2353                         }
2354                 } else {
2355                         deploymentArtifacts = component.getDeploymentArtifacts();
2356                 }
2357                 return deploymentArtifacts;
2358         }
2359
2360         // get deploymentArtifact of asset and artifactType -> generate new artifact that can be updated on the asset
2361         protected ArtifactReqDetails getUpdatedArtifact(Map<String, ArtifactDefinition> deploymentArtifacts, String artifactType) throws IOException, Exception {
2362                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2363
2364                 for (String key : deploymentArtifacts.keySet()) {
2365                         if (key.startsWith("ci")) {
2366                                 artifactReqDetails.setArtifactDisplayName(deploymentArtifacts.get(key).getArtifactDisplayName());
2367                                 artifactReqDetails.setArtifactName(deploymentArtifacts.get(key).getArtifactName());
2368                                 artifactReqDetails.setArtifactLabel(deploymentArtifacts.get(key).getArtifactLabel());
2369                                 break;
2370                         }
2371                 }
2372
2373                 return artifactReqDetails;
2374         }
2375
2376         // Happy flow - get chosen life cycle state, artifact type and asset type
2377         // update artifact via external API + check audit & response code
2378         // Download artifact via external API + check audit & response code
2379         // Check artifact version, uuid & checksusm
2380         protected Component updateArtifactOnAssetViaExternalAPI(Component component, ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
2381                 RestResponse restResponse = null;
2382                 int numberOfArtifact = 0;
2383                 String artifactVersionBeforeUpdate = null;
2384                 String artifactName = null;
2385                 String componentVersionBeforeUpdate = null;
2386
2387                 // get updated artifact data
2388                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2389                 String artifactUUID = null;
2390                 Map<String, ArtifactDefinition> deploymentArtifacts;
2391                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2392
2393                 for (String key : deploymentArtifacts.keySet()) {
2394                         if (key.startsWith("ci")) {
2395                                 artifactName = key;
2396                                 artifactVersionBeforeUpdate = deploymentArtifacts.get(key).getArtifactVersion();
2397                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2398                                 artifactReqDetails.setArtifactDisplayName(deploymentArtifacts.get(key).getArtifactDisplayName());
2399                                 artifactReqDetails.setArtifactName(deploymentArtifacts.get(key).getArtifactName());
2400                                 artifactReqDetails.setArtifactLabel(deploymentArtifacts.get(key).getArtifactLabel());
2401                                 break;
2402                         }
2403                 }
2404
2405                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
2406                 componentVersionBeforeUpdate = component.getVersion();
2407                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2408                 numberOfArtifact = deploymentArtifacts.size();
2409
2410                 // create component/s & upload artifact via external api
2411                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2412                         restResponse = updateArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID, 200);
2413                 } else {
2414                         restResponse = updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID, 200);
2415                 }
2416
2417                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2418                 component = getNewerVersionOfComponent(component, chosenLifeCycleState);
2419
2420                 // Get list of deployment artifact + download them via external API
2421                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2422                 Assert.assertEquals(numberOfArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will be same as before.");
2423                 Assert.assertEquals(String.valueOf((Integer.parseInt(artifactVersionBeforeUpdate) + 1)), deploymentArtifacts.get(artifactName).getArtifactVersion(), "Expected that aftifact version will increase by one.");
2424
2425                 if(chosenLifeCycleState == LifeCycleStatesEnum.CHECKOUT) {
2426                         Assert.assertEquals(componentVersionBeforeUpdate, component.getVersion(), "Expected that check-out component will not change version number.");
2427                 } else {
2428                         Assert.assertEquals(String.format("%.1f", (Double.parseDouble(componentVersionBeforeUpdate) + 0.1)), component.getVersion(), "Expected that non check-out component version will increase by 0.1.");
2429                 }
2430
2431                 // Download the uploaded artifact via external API
2432                 downloadResourceDeploymentArtifactExternalAPI(component, deploymentArtifacts.get(responseArtifact.getArtifactLabel()), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentTypeEnum);
2433
2434                 return component;
2435         }
2436
2437
2438         // Update artifact via external API + Check auditing for upload operation + Check response of external API
2439         protected RestResponse updateArtifactOfRIIncludingValiditionOfAuditAndResponseCode(Component component, ComponentInstance componentInstance, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
2440                 RestResponse restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfComponentInstanceOnAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, component.getComponentInstances().get(0), artifactUUID);
2441
2442                 // Check response of external API
2443                 Integer responseCode = restResponse.getErrorCode();
2444                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2445
2446
2447                 // Check auditing for upload operation
2448                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2449
2450                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2451
2452                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2453                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
2454
2455                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
2456                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, component);
2457 //              expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
2458                 expectedExternalAudit.setRESOURCE_NAME(componentInstance.getNormalizedName());
2459                 expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + component.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts/" + artifactUUID);
2460                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2461
2462                 return restResponse;
2463         }
2464
2465
2466         // Update artifact via external API + Check auditing for upload operation + Check response of external API
2467         protected RestResponse updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component component, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
2468                 RestResponse restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfTheAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID);
2469
2470                 // Check response of external API
2471                 Integer responseCode = restResponse.getErrorCode();
2472                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2473
2474
2475                 // Check auditing for upload operation
2476                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2477
2478                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2479
2480                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2481                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
2482
2483                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
2484                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, component);
2485                 expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
2486                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2487
2488                 return restResponse;
2489         }
2490
2491
2492
2493
2494         ////////////////////////////////////////////////////////////////////////////////////
2495         ////////////////////////////////////////////////////////////////////////////////////
2496         ////////////////////////////////////////////////////////////////////////////////////
2497         //                                      Delete External API                                                                                       //
2498         ////////////////////////////////////////////////////////////////////////////////////
2499         ////////////////////////////////////////////////////////////////////////////////////
2500         ////////////////////////////////////////////////////////////////////////////////////
2501         @DataProvider(name="deleteArtifactForServiceViaExternalAPI", parallel=true)
2502         public static Object[][] dataProviderDeleteArtifactForServiceViaExternalAPI() {
2503                 return new Object[][] {
2504                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
2505                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
2506                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
2507                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
2508                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2509                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
2510                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
2511                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
2512                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
2513                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
2514                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
2515                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
2516                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
2517                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
2518                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"},
2519                         {LifeCycleStatesEnum.CERTIFY, "YANG_XML"},
2520                         {LifeCycleStatesEnum.CERTIFY, "VNF_CATALOG"},
2521                         {LifeCycleStatesEnum.CERTIFY, "MODEL_INVENTORY_PROFILE"},
2522                         {LifeCycleStatesEnum.CERTIFY, "MODEL_QUERY_SPEC"},
2523                         {LifeCycleStatesEnum.CERTIFY, "OTHER"}
2524                         };
2525         }
2526
2527         // Delete artifact for Service - Success
2528         @Test(dataProvider="deleteArtifactForServiceViaExternalAPI")
2529         public void deleteArtifactForServiceViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
2530                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s", lifeCycleStatesEnum, artifactType));
2531                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.SERVICE, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
2532                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.SERVICE, lifeCycleStatesEnum);
2533         }
2534
2535         @DataProvider(name="deleteArtifactForVFViaExternalAPI", parallel=true)
2536         public static Object[][] dataProviderDeleteArtifactForVFViaExternalAPI() {
2537                 return new Object[][] {
2538                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_JSON"},
2539                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_POLICY"},
2540                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_EVENT"},
2541                         {LifeCycleStatesEnum.CHECKOUT, "APPC_CONFIG"},
2542                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_DOC"},
2543                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_TOSCA"},
2544                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
2545                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
2546                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE"},
2547                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE"},
2548                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
2549                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
2550                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2551
2552                         {LifeCycleStatesEnum.CHECKIN, "DCAE_JSON"},
2553                         {LifeCycleStatesEnum.CHECKIN, "DCAE_POLICY"},
2554                         {LifeCycleStatesEnum.CHECKIN, "DCAE_EVENT"},
2555                         {LifeCycleStatesEnum.CHECKIN, "APPC_CONFIG"},
2556                         {LifeCycleStatesEnum.CHECKIN, "DCAE_DOC"},
2557                         {LifeCycleStatesEnum.CHECKIN, "DCAE_TOSCA"},
2558                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
2559                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
2560                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE"},
2561                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE"},
2562                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
2563                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
2564                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
2565
2566                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_JSON"},
2567                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_POLICY"},
2568                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_EVENT"},
2569                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "APPC_CONFIG"},
2570                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_DOC"},
2571                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_TOSCA"},
2572                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
2573                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
2574                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE"},
2575                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE"},
2576                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
2577                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
2578                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"},
2579                         };
2580         }
2581
2582
2583         // Delete artifact for VF - Success
2584         @Test(dataProvider="deleteArtifactForVFViaExternalAPI")
2585         public void deleteArtifactForVFViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
2586                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s", lifeCycleStatesEnum, artifactType));
2587                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
2588                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE, lifeCycleStatesEnum);
2589         }
2590
2591         @DataProvider(name="deleteArtifactForVfcVlCpViaExternalAPI", parallel=true)
2592         public static Object[][] dataProviderDeleteArtifactForVfcVlCpViaExternalAPI() {
2593                 return new Object[][] {
2594                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VFC},
2595                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VFC},
2596                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VFC},
2597                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
2598                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
2599                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
2600                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VFC},
2601                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
2602                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
2603
2604                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VL},
2605                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VL},
2606                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VL},
2607                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VL},
2608                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
2609                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
2610                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VL},
2611                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
2612                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
2613
2614                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.CP},
2615                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.CP},
2616                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.CP},
2617                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.CP},
2618                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
2619                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
2620                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.CP},
2621                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
2622                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
2623
2624                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VFC},
2625                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VFC},
2626                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VFC},
2627                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
2628                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
2629                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
2630                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VFC},
2631                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
2632                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
2633
2634                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VL},
2635                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VL},
2636                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VL},
2637                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VL},
2638                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
2639                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
2640                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VL},
2641                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
2642                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
2643
2644                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.CP},
2645                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.CP},
2646                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.CP},
2647                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.CP},
2648                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
2649                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
2650                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.CP},
2651                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
2652                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
2653
2654                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VFC},
2655                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VFC},
2656                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VFC},
2657                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
2658                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
2659                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
2660                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VFC},
2661                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
2662                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
2663
2664                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VL},
2665                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VL},
2666                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VL},
2667                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VL},
2668                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
2669                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
2670                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VL},
2671                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
2672                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
2673
2674                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.CP},
2675                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.CP},
2676                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.CP},
2677                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.CP},
2678                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
2679                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
2680                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.CP},
2681                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
2682                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
2683                         };
2684         }
2685
2686
2687         // Delete artifact for VFC, VL, CP - Success
2688         @Test(dataProvider="deleteArtifactForVfcVlCpViaExternalAPI")
2689         public void deleteArtifactForVfcVlCpViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2690                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s, resourceTypeEnum: %s", lifeCycleStatesEnum, artifactType, resourceTypeEnum));
2691                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
2692                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE, lifeCycleStatesEnum);
2693         }
2694
2695         @DataProvider(name="deleteArtifactOnRIViaExternalAPI", parallel=true)
2696         public static Object[][] dataProviderDeleteArtifactOnRIViaExternalAPI() {
2697                 return new Object[][] {
2698                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", null},
2699                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", null},
2700                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", null},
2701                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", null},
2702                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", null},
2703                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", null},
2704
2705                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", null},
2706                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", null},
2707                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", null},
2708                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", null},
2709                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", null},
2710                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", null},
2711
2712                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
2713                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VF},
2714                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VF},
2715                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VF},
2716                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VF},
2717                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VF}
2718
2719                         };
2720         }
2721
2722
2723
2724
2725
2726         @Test(dataProvider="deleteArtifactOnRIViaExternalAPI")
2727         public void deleteArtifactOnRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2728                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
2729                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
2730                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState);
2731         }
2732
2733
2734         @DataProvider(name="deleteArtifactOnVfcVlCpRIViaExternalAPI", parallel=true)
2735         public static Object[][] dataProviderDeleteArtifactOnVfcVlCpRIViaExternalAPI() {
2736                 return new Object[][] {
2737                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
2738                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
2739                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
2740                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
2741                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
2742                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
2743                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
2744                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
2745
2746
2747                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
2748                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
2749                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
2750                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
2751                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
2752                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
2753                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
2754                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
2755
2756                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
2757                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP,},
2758                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
2759                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
2760                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
2761                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
2762                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
2763                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
2764
2765
2766                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
2767                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
2768                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
2769                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
2770                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
2771                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
2772                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
2773                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
2774
2775                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
2776                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
2777                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
2778                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
2779                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
2780                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
2781                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
2782                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
2783
2784                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
2785                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
2786                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
2787                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
2788                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
2789                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
2790                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
2791                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
2792
2793                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
2794                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
2795                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
2796                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
2797                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
2798                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
2799                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
2800                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
2801
2802                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
2803                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
2804                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
2805                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
2806                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
2807                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
2808                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
2809                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
2810
2811                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
2812                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
2813                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
2814                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
2815                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
2816                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
2817                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
2818                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
2819
2820                         };
2821         }
2822
2823
2824
2825
2826
2827         @Test(dataProvider="deleteArtifactOnVfcVlCpRIViaExternalAPI")
2828         public void deleteArtifactOnVfcVlCpRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2829                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
2830                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
2831                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState);
2832         }
2833
2834
2835         @DataProvider(name="deleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset", parallel=true)
2836         public static Object[][] dataProviderDeleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset() {
2837                 return new Object[][] {
2838                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2839                         {ComponentTypeEnum.SERVICE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2840                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2841
2842                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2843                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2844                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2845                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2846                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2847                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2848
2849                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2850                         {ComponentTypeEnum.SERVICE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2851                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2852                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2853                         {ComponentTypeEnum.SERVICE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2854                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2855
2856                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2857                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2858                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2859                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2860                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2861                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2862 //
2863                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2864                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2865                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2866                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2867                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2868                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2869
2870                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2871                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2872                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2873                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2874                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2875                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2876
2877                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2878                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2879                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2880                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2881                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2882                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2883                         };
2884         }
2885
2886
2887         // External API
2888         // Delete artifact by different user then creator of asset - Fail
2889         @Test(dataProvider="deleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset")
2890         public void deleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset(ComponentTypeEnum componentTypeEnum, UserRoleEnum userRoleEnum, LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
2891                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, userRoleEnum %s, lifeCycleStatesEnum %s, artifactType: %s", componentTypeEnum, userRoleEnum, lifeCycleStatesEnum, artifactType));
2892                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, lifeCycleStatesEnum, artifactType, null);
2893                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2894
2895                 String artifactUUID = null;
2896                 for (String key : deploymentArtifacts.keySet()) {
2897                         if (key.startsWith("ci")) {
2898                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2899                                 break;
2900                         }
2901                 }
2902
2903                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
2904                 List<String> variables = asList();
2905
2906                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
2907                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2908                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, lifeCycleStatesEnum, true);
2909                 } else {
2910                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2911                                         errorInfo.getCode(), null, artifactUUID, errorInfo, variables, lifeCycleStatesEnum, true);
2912                 }
2913
2914                 //TODO
2915 //              downloadResourceDeploymentArtifactExternalAPI(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, componentTypeEnum);
2916         }
2917
2918
2919         @DataProvider(name="deleteArtifactOnAssetWhichNotExist", parallel=true)
2920         public static Object[][] dataProviderDeleteArtifactOnAssetWhichNotExist() {
2921                 return new Object[][] {
2922                         {ComponentTypeEnum.SERVICE, "OTHER", null},
2923                         {ComponentTypeEnum.RESOURCE, "OTHER", null},
2924                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
2925                         };
2926         }
2927
2928
2929         // External API
2930         // Upload artifact on VF via external API - happy flow
2931         @Test(dataProvider="deleteArtifactOnAssetWhichNotExist")
2932         public void deleteArtifactOnAssetWhichNotExist(ComponentTypeEnum componentTypeEnum, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2933                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
2934                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, resourceTypeEnum);
2935
2936                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2937
2938                 String artifactUUID = null;
2939                 for (String key : deploymentArtifacts.keySet()) {
2940                         if (key.startsWith("ci")) {
2941                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2942                                 break;
2943                         }
2944                 }
2945
2946                 // Invalid artifactUUID
2947                 String invalidArtifactUUID = "12341234-1234-1234-1234-123412341234";
2948                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
2949                 List<String> variables = asList(invalidArtifactUUID);
2950
2951                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
2952                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2953                                         errorInfo.getCode(), component.getComponentInstances().get(0), invalidArtifactUUID, errorInfo, variables, null, true);
2954                 } else {
2955                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2956                                         errorInfo.getCode(), null, invalidArtifactUUID, errorInfo, variables, null, true);
2957
2958                 }
2959
2960
2961                 // Invalid componentUUID
2962                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
2963                         component.getComponentInstances().get(0).setNormalizedName("invalidNormalizedName");
2964                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER.name());
2965                         variables = asList("invalidNormalizedName", ComponentTypeEnum.RESOURCE_INSTANCE.getValue().toLowerCase(), ComponentTypeEnum.SERVICE.getValue(), component.getName());
2966                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2967                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, true);
2968                 } else {
2969                         component.setUUID("invalidComponentUUID");
2970                         if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE)) {
2971                                 errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
2972                         } else {
2973                                 errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.SERVICE_NOT_FOUND.name());
2974                         }
2975                         variables = asList("invalidComponentUUID");
2976                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2977                                         errorInfo.getCode(), null, artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, false);
2978                 }
2979
2980
2981 //              performeClean();
2982
2983         }
2984
2985         @DataProvider(name="deleteArtifactOnAssetWhichInInvalidStateForUploading", parallel=true)
2986         public static Object[][] dataProviderDeleteArtifactOnAssetWhichInInvalidStateForUploading() {
2987                 return new Object[][] {
2988                         {ComponentTypeEnum.SERVICE, "OTHER"},
2989                         {ComponentTypeEnum.RESOURCE, "OTHER"},
2990                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA"},
2991                         };
2992         }
2993
2994
2995         @Test(dataProvider="deleteArtifactOnAssetWhichInInvalidStateForUploading")
2996         public void deleteArtifactOnAssetWhichInInvalidStateForUploading(ComponentTypeEnum componentTypeEnum, String artifactType) throws Exception {
2997                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
2998                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
2999                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.STARTCERTIFICATION, true).getLeft();
3000
3001                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
3002                 String artifactUUID = null;
3003                 for (String key : deploymentArtifacts.keySet()) {
3004                         if (key.startsWith("ci")) {
3005                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
3006                                 break;
3007                         }
3008                 }
3009
3010
3011                 // Invalid artifactUUID
3012                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name());
3013                 List<String> variables = asList(component.getName(), component.getComponentType().toString().toLowerCase(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getFirstName(),
3014                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getLastName(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId());
3015
3016                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
3017                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3018                                         errorInfo.getCode(), component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, null, true);
3019                 } else {
3020                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3021                                         errorInfo.getCode(), null, artifactUUID, errorInfo, variables, null, true);
3022
3023                 }
3024
3025         }
3026
3027
3028         @DataProvider(name="deleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI", parallel=true)
3029         public static Object[][] dataProviderDeleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI() {
3030                 return new Object[][] {
3031                         {ResourceTypeEnum.VFC},
3032                         {ResourceTypeEnum.VL},
3033                         {ResourceTypeEnum.CP}
3034                         };
3035         }
3036
3037
3038         // Verify that it cannot delete VFC/VL/CP artifact on VFCi/VLi/CPi - Failure flow
3039         @Test(dataProvider="deleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI")
3040         public void deleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI(ResourceTypeEnum resourceTypeEnum) throws Exception {
3041                 getExtendTest().log(Status.INFO, String.format("resourceTypeEnum: %s", resourceTypeEnum));
3042
3043                 Component resourceInstanceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.getValue(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, resourceTypeEnum);
3044                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", "SNMP_TRAP", true, false);
3045                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceInstanceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
3046                 resourceInstanceDetails = AtomicOperationUtils.changeComponentState(resourceInstanceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
3047                 Component component = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
3048                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceInstanceDetails, component, UserRoleEnum.DESIGNER, true).left().value();
3049                 component = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
3050
3051                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
3052                 Map<String, ArtifactDefinition> deploymentArtifacts;
3053                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, ComponentTypeEnum.RESOURCE_INSTANCE);
3054                 String artifactUUID = null;
3055                 for (String key : deploymentArtifacts.keySet()) {
3056                         if (key.startsWith("ci")) {
3057                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
3058                                 break;
3059                         }
3060                 }
3061                 List<String> variables = asList(artifactUUID);
3062                 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3063                                 errorInfo.getCode(), component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, null, true);
3064         }
3065
3066         protected RestResponse deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component component, User sdncModifierDetails,
3067                         Integer expectedResponseCode, ComponentInstance componentInstance, String artifactUUID, ErrorInfo errorInfo, List<String> variables, LifeCycleStatesEnum lifeCycleStatesEnum, Boolean resourceNameInAudit) throws Exception {
3068                 RestResponse restResponse;
3069
3070                 if(componentInstance != null) {
3071                         restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfComponentInstanceOnAsset(component, sdncModifierDetails, componentInstance, artifactUUID);
3072                 } else {
3073                         restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfTheAsset(component, sdncModifierDetails, artifactUUID);
3074
3075                 }
3076
3077                 // validate response code
3078                 Integer responseCode = restResponse.getErrorCode();
3079                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3080
3081                 // Check auditing for upload operation
3082                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3083
3084                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3085
3086                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
3087 //              ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
3088
3089                 responseArtifact.setUpdaterFullName("");
3090                 responseArtifact.setUserIdLastUpdater(sdncModifierDetails.getUserId());
3091                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditFailure(assetTypeEnum, action, responseArtifact, component.getUUID(), errorInfo, variables);
3092                 expectedExternalAudit.setRESOURCE_NAME(component.getName());
3093                 expectedExternalAudit.setRESOURCE_TYPE(component.getComponentType().getValue());
3094                 expectedExternalAudit.setARTIFACT_DATA(null);
3095                 expectedExternalAudit.setCURR_ARTIFACT_UUID(artifactUUID);
3096                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3097                 body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
3098                 if(componentInstance != null) {
3099                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getComponentInstances().get(0).getNormalizedName());
3100                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + component.getUUID() + "/resourceInstances/" + component.getComponentInstances().get(0).getNormalizedName() + "/artifacts/" + artifactUUID);
3101                         expectedExternalAudit.setRESOURCE_NAME(component.getComponentInstances().get(0).getNormalizedName());
3102                 } else {
3103                         expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL() + "/" + artifactUUID);
3104                         if((errorInfo.getMessageId().equals(ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name()).getMessageId())) ||
3105                                         errorInfo.getMessageId().equals(ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name()).getMessageId()) ||
3106                                         (lifeCycleStatesEnum == LifeCycleStatesEnum.STARTCERTIFICATION)) {
3107                                 if(resourceNameInAudit) {
3108                                         expectedExternalAudit.setRESOURCE_NAME(component.getName());
3109                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
3110                                 } else {
3111                                         expectedExternalAudit.setRESOURCE_NAME("");
3112                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
3113                                 }
3114                         } else {
3115                                 if(resourceNameInAudit) {
3116                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
3117                                 } else {
3118                                         expectedExternalAudit.setRESOURCE_NAME("");
3119                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
3120                                 }
3121                         }
3122                 }
3123
3124 //              getExtendTest().log(LogStatus.INFO, "Audit Action: " + AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName());
3125 //              body.forEach((k,v)->getExtendTest().log(LogStatus.INFO,"key : " + k + " value : " + v));
3126                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3127
3128                 return restResponse;
3129
3130         }
3131
3132
3133         // Happy flow - get chosen life cycle state, artifact type and asset type
3134         // delete artifact via external API + check audit & response code
3135         protected Component deleteArtifactOnAssetViaExternalAPI(Component component, ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState) throws Exception {
3136                 String artifactName = null;
3137                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
3138                 if(!LifeCycleStatesEnum.CHECKOUT.equals(chosenLifeCycleState)){
3139                         component = AtomicOperationUtils.getComponentObject(component, UserRoleEnum.DESIGNER);
3140                 }else{
3141                         component = getNewerVersionOfComponent(component, chosenLifeCycleState);
3142                 }
3143                 // get updated artifact data
3144                 String artifactUUID = null;
3145                 int moduleTypeArtifact = 0;
3146                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
3147
3148                 for (String key : deploymentArtifacts.keySet()) {
3149                         if (key.startsWith("ci")  && StringUtils.isNotEmpty(deploymentArtifacts.get(key).getArtifactUUID())) {
3150                                 artifactName = key;
3151                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
3152
3153                                 if (deploymentArtifacts.get(key).getArtifactType().equals(ArtifactTypeEnum.VF_MODULES_METADATA)){
3154                                         moduleTypeArtifact = 1;
3155                                 }
3156                                 break;
3157                         }
3158                 }
3159
3160                 String componentVersionBeforeDelete = component.getVersion();
3161                 int numberOfArtifact = deploymentArtifacts.size();
3162
3163                 // create component/s & upload artifact via external api
3164                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
3165                         deleteArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, 200);
3166                 } else {
3167                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, 200);
3168                 }
3169
3170                 component = updateComponentDetailsByLifeCycleState(chosenLifeCycleState, component);
3171
3172                 // Get list of deployment artifact + download them via external API
3173                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
3174                 if(deploymentArtifacts.get(artifactName) != null) {
3175                         Assert.assertTrue(false, "Expected that deleted artifact will not appear in deployment artifact list.");
3176                 }
3177                 if((LifeCycleStatesEnum.CERTIFICATIONREQUEST.equals(chosenLifeCycleState)) && (ComponentTypeEnum.RESOURCE_INSTANCE.equals(componentTypeEnum)) && (!component.getComponentType().toString().equals(ComponentTypeEnum.RESOURCE.toString()))) {
3178                         Assert.assertEquals(numberOfArtifact - 1 - moduleTypeArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact (one deleted and one vfmodule) will decrease by two.");
3179                 } else {
3180                         Assert.assertEquals(numberOfArtifact - 1, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will decrease by one.");
3181                 }
3182
3183                 if(chosenLifeCycleState == LifeCycleStatesEnum.CHECKOUT) {
3184                         Assert.assertEquals(componentVersionBeforeDelete, component.getVersion(), "Expected that check-out component will not change version number.");
3185                 } else {
3186                         Assert.assertEquals(String.format("%.1f", (Double.parseDouble(componentVersionBeforeDelete) + 0.1)), component.getVersion(), "Expected that non check-out component version will increase by 0.1.");
3187                 }
3188
3189                 downloadResourceDeploymentArtifactExternalAPI(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, componentTypeEnum);
3190
3191                 return component;
3192         }
3193
3194         // Delete artifact via external API + Check auditing for upload operation + Check response of external API
3195         protected RestResponse deleteArtifactOfRIIncludingValiditionOfAuditAndResponseCode(Component component, ComponentInstance componentInstance, User sdncModifierDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
3196                 RestResponse restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfComponentInstanceOnAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), component.getComponentInstances().get(0), artifactUUID);
3197
3198                 // Check response of external API
3199                 Integer responseCode = restResponse.getErrorCode();
3200                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3201
3202
3203                 // Check auditing for upload operation
3204                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3205
3206                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3207
3208                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3209                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
3210
3211                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
3212                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, component);
3213 //              expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
3214                 expectedExternalAudit.setRESOURCE_NAME(componentInstance.getNormalizedName());
3215                 expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + component.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts/" + artifactUUID);
3216                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3217                 component = AtomicOperationUtils.getComponentObject(component, UserRoleEnum.DESIGNER);
3218                 return restResponse;
3219         }
3220
3221
3222         // Delete artifact via external API + Check auditing for upload operation + Check response of external API
3223         protected RestResponse deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component component, User sdncModifierDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
3224                 RestResponse restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfTheAsset(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID);
3225
3226                 // Check response of external API
3227                 Integer responseCode = restResponse.getErrorCode();
3228                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3229
3230
3231                 // Check auditing for upload operation
3232                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3233
3234                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3235
3236                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3237                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, component.getName());
3238
3239                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((component.getComponentType().getValue() + "s").toUpperCase());
3240                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, component);
3241                 expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
3242                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3243                 component = AtomicOperationUtils.getComponentObject(component, UserRoleEnum.DESIGNER);
3244                 return restResponse;
3245         }
3246
3247
3248
3249         // download deployment via external api + check response code for success (200) + get artifactReqDetails and verify payload + verify audit
3250         protected RestResponse downloadResourceDeploymentArtifactExternalAPI(Component component, User sdncModifierDetails, String artifactUUID, ComponentTypeEnum componentTypeEnum) throws Exception {
3251                 RestResponse restResponse;
3252
3253                 if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
3254                         restResponse = ArtifactRestUtils.getComponentInstanceDeploymentArtifactExternalAPI(component.getUUID(), component.getComponentInstances().get(0).getNormalizedName(), artifactUUID, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), component.getComponentType().toString());
3255                 } else {
3256                         restResponse = ArtifactRestUtils.getResourceDeploymentArtifactExternalAPI(component.getUUID(), artifactUUID, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), component.getComponentType().toString());
3257                 }
3258
3259                 Integer responseCode = restResponse.getErrorCode();
3260                 Integer expectedCode = 404;
3261                 Assert.assertEquals(responseCode,expectedCode, "Response code is not correct.");
3262
3263
3264                 //TODO - including body - resourceDetails.getName()
3265 //                      // Verify audit
3266 //                      String auditAction = "DownloadArtifact";
3267 //
3268 //                      Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3269 //                      body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
3270 //                      body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
3271 //
3272 //                      ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = new ExpectedResourceAuditJavaObject();
3273 //                      expectedResourceAuditJavaObject.setAction(auditAction);
3274 //                      expectedResourceAuditJavaObject.setResourceType(resourceDetails.getComponentType().getValue());
3275 //                      expectedResourceAuditJavaObject.setStatus("200");
3276 //                      expectedResourceAuditJavaObject.setDesc("OK");
3277 //                      expectedResourceAuditJavaObject.setCONSUMER_ID("ci");
3278 //
3279 //                      if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
3280 //                              expectedResourceAuditJavaObject.setResourceName(resourceDetails.getComponentInstances().get(0).getName());
3281 //                              String resource_url = String.format("/sdc/v1/catalog/services/%s/resourceInstances/%s/artifacts/%s", resourceDetails.getUUID(), resourceDetails.getComponentInstances().get(0).getNormalizedName(), artifactDefinition.getArtifactUUID());
3282 //                              expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
3283 //
3284 //                              AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
3285 //                      } else {
3286 //                              expectedResourceAuditJavaObject.setResourceName(resourceDetails.getName());
3287 //                              String resource_url = String.format("/sdc/v1/catalog/services/%s/artifacts/%s", resourceDetails.getUUID(), artifactDefinition.getArtifactUUID());
3288 //                              expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
3289 //                      }
3290 //
3291 //                      AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
3292
3293                 return restResponse;
3294
3295         }
3296
3297
3298
3299
3300         public Component getComponentInTargetLifeCycleState(String componentType, UserRoleEnum creatorUser, LifeCycleStatesEnum targetLifeCycleState, ResourceTypeEnum resourceTypeEnum) throws Exception {
3301                 Component resourceDetails = null;
3302
3303                 if((componentType.toLowerCase().equals("vf")) || (componentType.toLowerCase().equals("resource"))){
3304                         if(resourceTypeEnum==null) {
3305                                 resourceTypeEnum = ResourceTypeEnum.VF;
3306                         }
3307                         Either<Resource, RestResponse> createdResource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(resourceTypeEnum, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, creatorUser, true);
3308                         resourceDetails = createdResource.left().value();
3309                         resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, creatorUser, targetLifeCycleState, true).getLeft();
3310                 } else {
3311                         Either<Service, RestResponse> createdResource = AtomicOperationUtils.createDefaultService(creatorUser, true);
3312                         resourceDetails = createdResource.left().value();
3313                         // Add artifact to service if asked for certifcationrequest - must be at least one artifact for the flow
3314                         if((LifeCycleStatesEnum.CERTIFICATIONREQUEST == targetLifeCycleState) || (LifeCycleStatesEnum.STARTCERTIFICATION == targetLifeCycleState)) {
3315                                                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.OTHER, resourceDetails, UserRoleEnum.DESIGNER, true, true).left().value();
3316                         }
3317                         resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, creatorUser, targetLifeCycleState, true).getLeft();
3318                 }
3319
3320                 return resourceDetails;
3321         }
3322
3323
3324
3325
3326
3327         protected String createUploadArtifactBodyJson() {
3328                 Map<String, Object> jsonBody = new HashMap<String, Object>();
3329                 jsonBody.put("artifactName", UPLOAD_ARTIFACT_NAME);
3330                 jsonBody.put("artifactDisplayName", "configure");
3331                 jsonBody.put("artifactType", "SHELL");
3332                 jsonBody.put("mandatory", "false");
3333                 jsonBody.put("description", "ff");
3334                 jsonBody.put("payloadData", UPLOAD_ARTIFACT_PAYLOAD);
3335                 jsonBody.put("artifactLabel", "configure");
3336                 return gson.toJson(jsonBody);
3337         }
3338
3339         protected ArtifactDefinition getArtifactDataFromJson(String content) {
3340                 JsonObject jsonElement = new JsonObject();
3341                 ArtifactDefinition resourceInfo = null;
3342
3343                 try {
3344                         Gson gson = new Gson();
3345                         jsonElement = gson.fromJson(content, jsonElement.getClass());
3346                         JsonElement artifactGroupValue = jsonElement.get(Constants.ARTIFACT_GROUP_TYPE_FIELD);
3347                         if (artifactGroupValue != null && !artifactGroupValue.isJsonNull()) {
3348                                 String groupValueUpper = artifactGroupValue.getAsString().toUpperCase();
3349                                 if (!ArtifactGroupTypeEnum.getAllTypes().contains(groupValueUpper)) {
3350                                         StringBuilder sb = new StringBuilder();
3351                                         for (String value : ArtifactGroupTypeEnum.getAllTypes()) {
3352                                                 sb.append(value).append(", ");
3353                                         }
3354                                         log.debug("artifactGroupType is {}. valid values are: {}", groupValueUpper, sb.toString());
3355                                         return null;
3356                                 } else {
3357                                         jsonElement.remove(Constants.ARTIFACT_GROUP_TYPE_FIELD);
3358                                         jsonElement.addProperty(Constants.ARTIFACT_GROUP_TYPE_FIELD, groupValueUpper);
3359                                 }
3360                         }
3361                         String payload = null;
3362                         JsonElement artifactPayload = jsonElement.get(Constants.ARTIFACT_PAYLOAD_DATA);
3363                         if (artifactPayload != null && !artifactPayload.isJsonNull()) {
3364                                 payload = artifactPayload.getAsString();
3365                         }
3366                         jsonElement.remove(Constants.ARTIFACT_PAYLOAD_DATA);
3367                         String json = gson.toJson(jsonElement);
3368                         ObjectMapper mapper = new ObjectMapper();
3369                         mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
3370                         mapper.configure(Feature.FAIL_ON_EMPTY_BEANS, false);
3371                         mapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL);
3372
3373                         resourceInfo = mapper.readValue(json, ArtifactDefinition.class);
3374                         resourceInfo.setPayloadData(payload);
3375
3376                 } catch (Exception e) {
3377                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeArtifactInformationInvalidError, "Artifact Upload / Update");
3378                         BeEcompErrorManager.getInstance().logBeArtifactInformationInvalidError("Artifact Upload / Update");
3379                         log.debug("Failed to convert the content {} to object.", content.substring(0, Math.min(50, content.length())), e);
3380                 }
3381
3382                 return resourceInfo;
3383         }
3384
3385         protected HttpGet createGetRequest(String url) {
3386                 HttpGet httpGet = new HttpGet(url);
3387                 httpGet.addHeader(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
3388                 httpGet.addHeader(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
3389                 httpGet.addHeader(HttpHeaderEnum.USER_ID.getValue(), sdncUserDetails.getUserId());
3390                 return httpGet;
3391         }
3392
3393         protected String getArtifactUid(HttpResponse response) throws HttpResponseException, IOException, ParseException {
3394                 String responseString = new BasicResponseHandler().handleResponse(response);
3395                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3396                 String artifactId = (String) responseMap.get("uniqueId");
3397                 return artifactId;
3398         }
3399
3400         protected String getArtifactEsId(HttpResponse response) throws HttpResponseException, IOException, ParseException {
3401                 String responseString = new BasicResponseHandler().handleResponse(response);
3402                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3403                 String esId = (String) responseMap.get("EsId");
3404                 return esId;
3405         }
3406
3407         protected ArtifactDefinition addArtifactDataFromResponse(HttpResponse response, ArtifactDefinition artifact) throws HttpResponseException, IOException, ParseException {
3408                 //String responseString = new BasicResponseHandler().handleResponse(response);
3409                 HttpEntity entity = response.getEntity();
3410                 String responseString = EntityUtils.toString(entity);
3411                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3412                 artifact.setEsId((String)responseMap.get("esId"));
3413                 artifact.setUniqueId((String) responseMap.get("uniqueId"));
3414                 artifact.setArtifactGroupType(ArtifactGroupTypeEnum.findType((String) responseMap.get("artifactGroupType")));
3415                 artifact.setTimeout(((Long) responseMap.get("timeout")).intValue());
3416                 return artifact;
3417         }
3418
3419         protected String getLifecycleArtifactUid(CloseableHttpResponse response) throws HttpResponseException, IOException, ParseException {
3420                 String responseString = new BasicResponseHandler().handleResponse(response);
3421                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3422                 responseMap = (JSONObject) responseMap.get("implementation");
3423                 String artifactId = (String) responseMap.get("uniqueId");
3424                 return artifactId;
3425         }
3426
3427         protected HttpDelete createDeleteArtifactRequest(String url) {
3428                 HttpDelete httpDelete = new HttpDelete(url);
3429                 httpDelete.addHeader(HttpHeaderEnum.USER_ID.getValue(), sdncUserDetails.getUserId());
3430                 httpDelete.addHeader(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
3431                 return httpDelete;
3432         }
3433
3434         protected HttpPost createPostAddArtifactRequeast(String jsonBody, String url, boolean addMd5Header) throws UnsupportedEncodingException {
3435                 HttpPost httppost = new HttpPost(url);
3436                 httppost.addHeader(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
3437                 httppost.addHeader(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
3438                 httppost.addHeader(HttpHeaderEnum.USER_ID.getValue(), sdncUserDetails.getUserId());
3439                 if (addMd5Header) {
3440                         httppost.addHeader(HttpHeaderEnum.Content_MD5.getValue(), GeneralUtility.calculateMD5ByString(jsonBody));
3441                 }
3442                 StringEntity input = new StringEntity(jsonBody);
3443                 input.setContentType("application/json");
3444                 httppost.setEntity(input);
3445                 log.debug("Executing request {}" , httppost.getRequestLine());
3446                 return httppost;
3447         }
3448
3449         protected String createLoadArtifactBody() {
3450                 Map<String, Object> json = new HashMap<String, Object>();
3451                 json.put("artifactName", "install_apache2.sh");
3452                 json.put("artifactType", "SHELL");
3453                 json.put("description", "ddd");
3454                 json.put("payloadData", "UEsDBAoAAAAIAAeLb0bDQz");
3455                 json.put("artifactLabel", "name123");
3456
3457                 String jsonStr = gson.toJson(json);
3458                 return jsonStr;
3459         }
3460
3461         protected void checkDeleteResponse(RestResponse response) {
3462                 BaseRestUtils.checkStatusCode(response, "delete request failed", false, 204, 404);
3463         }
3464
3465         protected ArtifactUiDownloadData getArtifactUiDownloadData(String artifactUiDownloadDataStr) throws Exception {
3466
3467                 ObjectMapper mapper = new ObjectMapper();
3468                 try {
3469                         ArtifactUiDownloadData artifactUiDownloadData = mapper.readValue(artifactUiDownloadDataStr, ArtifactUiDownloadData.class);
3470                         return artifactUiDownloadData;
3471                 } catch (Exception e) {
3472                         e.printStackTrace();
3473                 }
3474                 return null;
3475         }
3476
3477
3478 }