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.AutomationUtils;
  84 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  85 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  86 import org.openecomp.sdc.ci.tests.utils.validation.DistributionValidationUtils;
  87 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  88 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  89 import org.openecomp.sdc.common.api.Constants;
  90 import org.openecomp.sdc.common.config.EcompErrorName;
  91 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  92 import org.openecomp.sdc.common.util.GeneralUtility;
  93 import org.slf4j.Logger;
  94 import org.slf4j.LoggerFactory;
  95 import org.testng.Assert;
  96 import org.testng.SkipException;
  97 import org.testng.annotations.DataProvider;
  98 import org.testng.annotations.Test;
  99
 100 import com.aventstack.extentreports.Status;
 101 import com.google.gson.Gson;
 102 import com.google.gson.JsonElement;
 103 import com.google.gson.JsonObject;
 104
 105 import fj.data.Either;
 106
 107 public class CRUDExternalAPI extends ComponentBaseTest {
 108
 109         private static Logger log = LoggerFactory.getLogger(CRUDExternalAPI.class.getName());
 110         protected static final String UPLOAD_ARTIFACT_PAYLOAD = "UHVUVFktVXNlci1LZXktRmlsZS0yOiBzc2gtcnNhDQpFbmNyeXB0aW9uOiBhZXMyNTYtY2JjDQpDb21tZW5wOA0K";
 111         protected static final String UPLOAD_ARTIFACT_NAME = "TLV_prv.ppk";
 112
 113         protected Config config = Config.instance();
 114         protected String contentTypeHeaderData = "application/json";
 115         protected String acceptHeaderDate = "application/json";
 116
 117         protected Gson gson = new Gson();
 118         protected JSONParser jsonParser = new JSONParser();
 119
 120         protected String serviceVersion;
 121         protected ResourceReqDetails resourceDetails;
 122         protected User sdncUserDetails;
 123         protected ServiceReqDetails serviceDetails;
 124
 125         @Rule
 126         public static TestName name = new TestName();
 127
 128         public CRUDExternalAPI() {
 129                 super(name, CRUDExternalAPI.class.getName());
 130         }
 131
 132         @DataProvider(name="uploadArtifactOnVfcVlCpViaExternalAPI" , parallel=false)
 133         public static Object[][] dataProviderUploadArtifactOnVfcVlCpViaExternalAPI() {
 134                 return new Object[][] {
 135                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VFC},
 136                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VFC},
 137                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VFC},
 138                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
 139                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
 140                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
 141                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VFC},
 142                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
 143                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
 144
 145                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VL},
 146                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VL},
 147                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VL},
 148                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VL},
 149                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
 150                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
 151                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VL},
 152                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
 153                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
 154
 155                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.CP},
 156                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.CP},
 157                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.CP},
 158                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.CP},
 159                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
 160                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
 161                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.CP},
 162                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
 163                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
 164
 165                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VFC},
 166                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VFC},
 167                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VFC},
 168                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
 169                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
 170                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
 171                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VFC},
 172                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
 173                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
 174
 175                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VL},
 176                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VL},
 177                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VL},
 178                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VL},
 179                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
 180                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
 181                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VL},
 182                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
 183                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
 184
 185                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.CP},
 186                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.CP},
 187                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.CP},
 188                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.CP},
 189                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
 190                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
 191                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.CP},
 192                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
 193                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
 194
 195                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VFC},
 196                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VFC},
 197                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VFC},
 198                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
 199                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
 200                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
 201                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VFC},
 202                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
 203                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
 204
 205                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VL},
 206                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VL},
 207                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VL},
 208                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VL},
 209                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
 210                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
 211                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VL},
 212                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
 213                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
 214
 215                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.CP},
 216                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.CP},
 217                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.CP},
 218                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.CP},
 219                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
 220                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
 221                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.CP},
 222                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
 223                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
 224                         };
 225         }
 226
 227         // External API
 228         // Upload artifact on VFC, VL, CP via external API - happy flow
 229         @Test(dataProvider="uploadArtifactOnVfcVlCpViaExternalAPI")
 230         public void uploadArtifactOnVfcVlCpViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
 231                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s, resourceTypeEnum: %s", chosenLifeCycleState, artifactType, resourceTypeEnum));
 232                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, chosenLifeCycleState, artifactType, resourceTypeEnum);
 233         }
 234
 235         @DataProvider(name="uploadArtifactOnVFViaExternalAPI", parallel=false)
 236         public static Object[][] dataProviderUploadArtifactOnVFViaExternalAPI() {
 237                 return new Object[][] {
 238                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_JSON"},
 239                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_POLICY"},
 240                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_EVENT"},
 241                         {LifeCycleStatesEnum.CHECKOUT, "APPC_CONFIG"},
 242                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_DOC"},
 243                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_TOSCA"},
 244                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
 245                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
 246                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE"},
 247                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE"},
 248                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
 249                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
 250                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
 251
 252                         {LifeCycleStatesEnum.CHECKIN, "DCAE_JSON"},
 253                         {LifeCycleStatesEnum.CHECKIN, "DCAE_POLICY"},
 254                         {LifeCycleStatesEnum.CHECKIN, "DCAE_EVENT"},
 255                         {LifeCycleStatesEnum.CHECKIN, "APPC_CONFIG"},
 256                         {LifeCycleStatesEnum.CHECKIN, "DCAE_DOC"},
 257                         {LifeCycleStatesEnum.CHECKIN, "DCAE_TOSCA"},
 258                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
 259                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
 260                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE"},
 261                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE"},
 262                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
 263                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
 264                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
 265
 266                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_JSON"},
 267                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_POLICY"},
 268                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_EVENT"},
 269                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "APPC_CONFIG"},
 270                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_DOC"},
 271                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_TOSCA"},
 272                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
 273                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
 274                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE"},
 275                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE"},
 276                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
 277                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
 278                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"}
 279                         };
 280         }
 281
 282         // External API
 283         // Upload artifact on VF via external API - happy flow
 284         @Test(dataProvider="uploadArtifactOnVFViaExternalAPI")
 285         public void uploadArtifactOnVFViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
 286                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 287                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, chosenLifeCycleState, artifactType, null);
 288         }
 289
 290
 291         @DataProvider(name="uploadArtifactOnServiceViaExternalAPI" , parallel=false)
 292         public static Object[][] dataProviderUploadArtifactOnServiceViaExternalAPI() {
 293                 return new Object[][] {
 294                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
 295                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
 296                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
 297                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
 298                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
 299                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
 300                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
 301                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
 302                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
 303                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
 304                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
 305                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
 306                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
 307                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
 308                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"}
 309                         };
 310         }
 311
 312
 313         @Test(dataProvider="uploadArtifactOnServiceViaExternalAPI")
 314         public void uploadArtifactOnServiceViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
 315                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 316                 uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.SERVICE, chosenLifeCycleState, artifactType, null);
 317         }
 318
 319
 320         @DataProvider(name="uploadArtifactOnServiceViaExternalAPIIncludingDistribution", parallel=false)
 321         public static Object[][] dataProviderUploadArtifactOnServiceViaExternalAPIIncludingDistribution() {
 322                 return new Object[][] {
 323                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
 324                         };
 325         }
 326
 327         @Test(dataProvider="uploadArtifactOnServiceViaExternalAPIIncludingDistribution")
 328         public void uploadArtifactOnServiceViaExternalAPIIncludingDistribution(LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
 329                 if(true){
 330                         throw new SkipException("Automated TC need repair.");
 331                 }
 332
 333                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
 334                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.SERVICE, chosenLifeCycleState, artifactType, null);
 335
 336                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 337
 338                 if(config.getIsDistributionClientRunning()){
 339                         List<String> distributionStatusList = Arrays.asList(DistributionNotificationStatusEnum.DOWNLOAD_OK.toString(), DistributionNotificationStatusEnum.DEPLOY_OK.toString(), DistributionNotificationStatusEnum.NOTIFIED.toString());
 340                         DistributionValidationUtils.validateDistributedArtifactsByAudit((Service)component, distributionStatusList);
 341                 }
 342         }
 343
 344
 345         // Happy flow - get chosen life cycle state, artifact type and asset type
 346         // Create asset, upload artifact via external API + check audit & response code
 347         // Download artifact via external API + check audit & response code
 348         protected Component uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
 349                 Component component = null;
 350                 RestResponse restResponse;
 351                 int numberOfArtifact = 0;
 352
 353                 // get artifact data
 354                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, false);
 355
 356                 // create component/s & upload artifact via external api
 357                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
 358                         component = getComponentWithResourceInstanceInTargetLifeCycleState(chosenLifeCycleState, resourceTypeEnum);
 359
 360                         restResponse = uploadArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
 361                         component =AtomicOperationUtils.getCompoenntObject(component, UserRoleEnum.DESIGNER);
 362
 363                         if((LifeCycleStatesEnum.CERTIFICATIONREQUEST == chosenLifeCycleState) && (!component.getComponentType().toString().equals(ComponentTypeEnum.RESOURCE.toString()))) {
 364 //                              numberOfArtifact = component.getComponentInstances().get(0).getDeploymentArtifacts().size();
 365                                 numberOfArtifact = (component.getComponentInstances().get(0).getDeploymentArtifacts() == null ? 0 : component.getComponentInstances().get(0).getDeploymentArtifacts().size());
 366                         } else {
 367 //                              numberOfArtifact = component.getComponentInstances().get(0).getDeploymentArtifacts().size() + 1;
 368                                 numberOfArtifact = (component.getComponentInstances().get(0).getDeploymentArtifacts() == null ? 0 : component.getComponentInstances().get(0).getDeploymentArtifacts().size());
 369                         }
 370                 } else {
 371                         component = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, chosenLifeCycleState, resourceTypeEnum);
 372
 373                         restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
 374                         numberOfArtifact = component.getDeploymentArtifacts().size() + 1;
 375                 }
 376
 377
 378
 379                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
 380                 component = getNewerVersionOfComponent(component, chosenLifeCycleState);
 381
 382                 // Get list of deployment artifact + download them via external API
 383                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
 384                 Assert.assertEquals(numberOfArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will be increase by one.");
 385
 386                 // Download the uploaded artifact via external API
 387                 downloadResourceDeploymentArtifactExternalAPI(component, deploymentArtifacts.get(responseArtifact.getArtifactLabel()), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentTypeEnum);
 388
 389                 return component;
 390         }
 391
 392         // Upload artifact via external API + Check auditing for upload operation + Check response of external API
 393         public RestResponse uploadArtifactOfRIIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, ComponentInstance componentInstance, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, Integer expectedResponseCode) throws Exception {
 394                 RestResponse restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfComponentInstanceOnAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, resourceDetails.getComponentInstances().get(0));
 395
 396                 // Check response of external API
 397                 Integer responseCode = restResponse.getErrorCode();
 398                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
 399
 400
 401                 // Check auditing for upload operation
 402                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
 403
 404                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
 405
 406                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 407                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
 408
 409                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
 410                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
 411                 expectedExternalAudit.setRESOURCE_NAME(componentInstance.getNormalizedName());
 412                 expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts");
 413                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
 414
 415                 return restResponse;
 416         }
 417
 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 certifcationrequest - 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 resourceDetails, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, Integer expectedResponseCode) throws Exception {
 450                 RestResponse restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(resourceDetails, 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, resourceDetails.getName());
 464
 465                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
 466                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
 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 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 diffrent 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 resourceDetails, ArtifactDefinition artifactDefinition, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, ComponentTypeEnum componentTypeEnum) throws Exception {
 522                 RestResponse restResponse;
 523
 524                 if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
 525                         restResponse = ArtifactRestUtils.getComponentInstanceDeploymentArtifactExternalAPI(resourceDetails.getUUID(), resourceDetails.getComponentInstances().get(0).getNormalizedName(), artifactDefinition.getArtifactUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getComponentType().toString());
 526                 } else {
 527                         restResponse = ArtifactRestUtils.getResourceDeploymentArtifactExternalAPI(resourceDetails.getUUID(), artifactDefinition.getArtifactUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.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 artfaict
 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 resourceDetails, ArtifactDefinition artifactDefinition, User sdncModifierDetails) throws Exception {
 579                 downloadResourceDeploymentArtifactExternalAPI(resourceDetails, artifactDefinition, sdncModifierDetails, null, resourceDetails.getComponentType());
 580         }
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590         @DataProvider(name="uploadArtifactOnRIViaExternalAPI", parallel=false)
 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=false)
 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=false)
 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, 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(resourceDetails, 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 resourceDetails, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
1011                         ComponentInstance componentResourceInstanceDetails) throws Exception {
1012
1013                 RestResponse restResponse = null;
1014                 if(componentResourceInstanceDetails != null) {
1015                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfComponentInstanceOnAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
1016                 } else {
1017                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(resourceDetails, 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(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1026                                 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null, false);
1027         }
1028
1029         protected RestResponse uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, 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(resourceDetails, sdncModifierDetails, artifactReqDetails, componentResourceInstanceDetails);
1035                 } else {
1036                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(resourceDetails, 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((resourceDetails.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, resourceDetails.getUUID(), errorInfo, variables);
1055                 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getName());
1056                 expectedExternalAudit.setRESOURCE_TYPE(resourceDetails.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, resourceDetails.getComponentInstances().get(0).getNormalizedName());
1062                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts");
1063                         expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
1064                 } else {
1065                         if(includeResourceNameInAudit) {
1066                                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.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, resourceDetails.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 resourceDetails, 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(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
1094                 } else {
1095                         restResponse = ArtifactRestUtils.externalAPIUploadArtifactWithInvalidCheckSumOfTheAsset(resourceDetails, 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((resourceDetails.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, resourceDetails.getUUID(), errorInfo, variables);
1118                 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getName());
1119                 expectedExternalAudit.setRESOURCE_TYPE(resourceDetails.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, resourceDetails.getComponentInstances().get(0).getNormalizedName());
1125                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts");
1126                         expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
1127                 } else {
1128                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.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=false)
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=false)
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=false)
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=false)
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=false)
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=false)
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=false)
1537         public static Object[][] dataProviderUpdateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI() {
1538                 return new Object[][] {
1539                         {ResourceTypeEnum.VFC},
1540                         {ResourceTypeEnum.VL},
1541                         {ResourceTypeEnum.CP}
1542                         };
1543         }
1544
1545
1546         // Verify that it cannot update VFC/VL/CP artifact on VFCi/VLi/CPi - Failure flow
1547         @Test(dataProvider="updateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI")
1548         public void updateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI(ResourceTypeEnum resourceTypeEnum) throws Exception {
1549                 getExtendTest().log(Status.INFO, String.format("resourceTypeEnum: %s", resourceTypeEnum));
1550
1551                 Component resourceInstanceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.getValue(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, resourceTypeEnum);
1552                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", "SNMP_TRAP", true, false);
1553                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceInstanceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
1554                 resourceInstanceDetails = AtomicOperationUtils.changeComponentState(resourceInstanceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
1555                 Component component = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
1556                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceInstanceDetails, component, UserRoleEnum.DESIGNER, true).left().value();
1557                 component = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
1558
1559                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
1560                 Map<String, ArtifactDefinition> deploymentArtifacts;
1561                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, ComponentTypeEnum.RESOURCE_INSTANCE);
1562                 String artifactUUID = null;
1563                 for (String key : deploymentArtifacts.keySet()) {
1564                         if (key.startsWith("ci") && StringUtils.isNotEmpty(deploymentArtifacts.get(key).getArtifactUUID())) {
1565                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
1566                                 break;
1567                         }
1568                 }
1569                 List<String> variables = asList(artifactUUID);
1570                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", errorInfo, variables, UserRoleEnum.DESIGNER, 404);
1571
1572         }
1573
1574
1575
1576
1577
1578         @DataProvider(name="updateArtifactOnRIViaExternalAPI", parallel=false)
1579         public static Object[][] dataProviderUpdateArtifactOnRIViaExternalAPI() {
1580                 return new Object[][] {
1581                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", null},
1582                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", null},
1583                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", null},
1584                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", null},
1585                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", null},
1586                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", null},
1587
1588                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", null},
1589                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", null},
1590                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", null},
1591                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", null},
1592                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", null},
1593                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", null},
1594
1595                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
1596                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VF},
1597                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VF},
1598                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VF},
1599                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VF},
1600                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VF}
1601
1602                         };
1603         }
1604
1605
1606
1607
1608
1609         @Test(dataProvider="updateArtifactOnRIViaExternalAPI")
1610         public void updateArtifactOnRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
1611                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
1612                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
1613                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState, artifactType);
1614
1615                 // for certify version check that previous version exist, and that it artifact can be download + checksum
1616                 if(chosenLifeCycleState.equals(LifeCycleStatesEnum.CERTIFY)) {
1617                         // Download the uploaded artifact via external API
1618                         downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(component, artifactType, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ComponentTypeEnum.RESOURCE_INSTANCE);
1619                 }
1620         }
1621
1622
1623
1624
1625
1626
1627
1628         @DataProvider(name="updateArtifactOnVfcVlCpRIViaExternalAPI", parallel=false)
1629         public static Object[][] dataProviderUpdateArtifactOnVfcVlCpRIViaExternalAPI() {
1630                 return new Object[][] {
1631                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
1632                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
1633                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
1634                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
1635                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
1636                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
1637                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
1638                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
1639
1640
1641                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
1642                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
1643                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
1644                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
1645                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
1646                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
1647                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
1648                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
1649
1650                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
1651                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
1652                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
1653                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
1654                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
1655                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
1656                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
1657                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
1658
1659
1660                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
1661                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
1662                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
1663                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
1664                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
1665                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
1666                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
1667                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
1668
1669                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
1670                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
1671                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
1672                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
1673                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
1674                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
1675                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
1676                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
1677
1678                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
1679                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
1680                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
1681                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
1682                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
1683                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
1684                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
1685                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
1686
1687                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
1688                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
1689                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
1690                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
1691                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
1692                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
1693                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
1694                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
1695
1696                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
1697                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
1698                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
1699                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
1700                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
1701                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
1702                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
1703                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
1704
1705                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
1706                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
1707                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
1708                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
1709                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
1710                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
1711                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
1712                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
1713
1714                         };
1715         }
1716
1717
1718
1719
1720
1721         @Test(dataProvider="updateArtifactOnVfcVlCpRIViaExternalAPI")
1722         public void updateArtifactOnVfcVlCpRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
1723                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
1724                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
1725                 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState, artifactType);
1726
1727
1728                 // for certify version check that previous version exist, and that it artifact can be download + checksum
1729                 if(chosenLifeCycleState.equals(LifeCycleStatesEnum.CERTIFY)) {
1730                         // Download the uploaded artifact via external API
1731                         downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(component, artifactType, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), ComponentTypeEnum.RESOURCE_INSTANCE);
1732                 }
1733         }
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744         @DataProvider(name="updateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset", parallel=false)
1745         public static Object[][] dataProviderUpdateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset() {
1746                 return new Object[][] {
1747                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1748                         {ComponentTypeEnum.SERVICE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1749                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1750
1751                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1752                         {ComponentTypeEnum.SERVICE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1753                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1754
1755                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1756                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1757                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1758                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1759                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1760                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1761
1762                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1763                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1764                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1765                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1766                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1767                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1768
1769                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1770                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1771                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1772                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1773                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1774                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1775
1776                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1777                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1778                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1779                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1780                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1781                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1782
1783                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1784                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
1785                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
1786                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1787                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
1788                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
1789                         };
1790         }
1791
1792
1793
1794         // External API
1795         // Update artifact by diffrent user then creator of asset - Fail
1796         @Test(dataProvider="updateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset")
1797         public void updateArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset(ComponentTypeEnum componentTypeEnum, UserRoleEnum userRoleEnum, LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
1798                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, userRoleEnum: %s, lifeCycleStatesEnum: %s, artifactType: %s", componentTypeEnum, userRoleEnum, lifeCycleStatesEnum, artifactType));
1799                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1800                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
1801                 List<String> variables = asList();
1802                 updateArtifactOnAssetViaExternalAPI(component, componentTypeEnum, lifeCycleStatesEnum, artifactType, errorInfo, variables, userRoleEnum, 409);
1803         }
1804
1805
1806         @DataProvider(name="updateArtifactOnAssetWhichNotExist", parallel=false)
1807         public static Object[][] dataProviderUpdateArtifactOnAssetWhichNotExist() {
1808                 return new Object[][] {
1809                         {ComponentTypeEnum.SERVICE, "OTHER", null},
1810                         {ComponentTypeEnum.RESOURCE, "OTHER", null},
1811                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
1812                         };
1813         }
1814
1815
1816
1817         // External API
1818         // Upload artifact on VF via external API - happy flow
1819         @Test(dataProvider="updateArtifactOnAssetWhichNotExist")
1820         public void updateArtifactOnAssetWhichNotExist(ComponentTypeEnum componentTypeEnum, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
1821                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
1822                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, resourceTypeEnum);
1823
1824                 // get updated artifact data
1825                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
1826                 ArtifactReqDetails artifactReqDetails = getUpdatedArtifact(deploymentArtifacts, artifactType);
1827                 String artifactUUID = deploymentArtifacts.get(artifactReqDetails.getArtifactLabel()).getArtifactUUID();
1828
1829                 // Invalid artifactUUID
1830                 String invalidArtifactUUID = "12341234-1234-1234-1234-123412341234";
1831                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
1832                 List<String> variables = asList(invalidArtifactUUID);
1833
1834                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1835                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1836                                         404, component.getComponentInstances().get(0), artifactReqDetails, invalidArtifactUUID, errorInfo, variables, null, true);
1837                 } else {
1838                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1839                                         404, null, artifactReqDetails, invalidArtifactUUID, errorInfo, variables, null, true);
1840
1841                 }
1842
1843                 // Invalid componentUUID
1844 //              errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
1845 //              variables = asList("null");
1846
1847                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1848                         component.getComponentInstances().get(0).setNormalizedName("invalidNormalizedName");
1849
1850                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER.name());
1851
1852                         variables = asList("invalidNormalizedName", ComponentTypeEnum.RESOURCE_INSTANCE.getValue().toLowerCase(), ComponentTypeEnum.SERVICE.getValue(), component.getName());
1853                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1854                                         404, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, true);
1855                 } else {
1856                         component.setUUID("invalidComponentUUID");
1857
1858                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
1859                         variables = asList("null");
1860
1861                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1862                                         404, null, artifactReqDetails, artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, false);
1863                 }
1864
1865                 performClean();
1866         }
1867
1868
1869         @DataProvider(name="updateArtifactOnAssetWhichInInvalidStateForUploading", parallel=false)
1870         public static Object[][] dataProviderUpdateProviderDeleteArtifactOnAssetWhichInInvalidStateForUploading() {
1871                 return new Object[][] {
1872                         {ComponentTypeEnum.SERVICE, "OTHER"},
1873                         {ComponentTypeEnum.RESOURCE, "OTHER"},
1874                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA"},
1875                         };
1876         }
1877
1878
1879         @Test(dataProvider="updateArtifactOnAssetWhichInInvalidStateForUploading")
1880         public void updateArtifactOnAssetWhichInInvalidStateForUploading(ComponentTypeEnum componentTypeEnum, String artifactType) throws Exception {
1881                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
1882                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1883                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name());
1884                 List<String> variables = asList(component.getName(), component.getComponentType().toString().toLowerCase(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getFirstName(),
1885                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getLastName(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId());
1886                 updateArtifactOnAssetViaExternalAPI(component, componentTypeEnum, LifeCycleStatesEnum.STARTCERTIFICATION, artifactType, errorInfo, variables, UserRoleEnum.DESIGNER, 403);
1887
1888         }
1889
1890
1891
1892
1893
1894         @DataProvider(name="updateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI", parallel=false)
1895         public static Object[][] dataProviderUpdateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI() {
1896                 return new Object[][] {
1897                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidCheckSum"},
1898                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidCheckSum"},
1899                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidCheckSum"},
1900                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidCheckSum"},
1901                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidCheckSum"},
1902                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidCheckSum"},
1903                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidCheckSum"},
1904                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidCheckSum"},
1905                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidCheckSum"},
1906
1907                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameToLong"},
1908                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameToLong"},
1909                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameToLong"},
1910                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameToLong"},
1911                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameToLong"},
1912                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameToLong"},
1913                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameToLong"},
1914                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameToLong"},
1915                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameToLong"},
1916
1917                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameEmpty"},
1918                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameEmpty"},
1919                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameEmpty"},
1920                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameEmpty"},
1921                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameEmpty"},
1922                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameEmpty"},
1923                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidNameEmpty"},
1924                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidNameEmpty"},
1925                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidNameEmpty"},
1926
1927                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelToLong"},
1928                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelToLong"},
1929                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelToLong"},
1930                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelToLong"},
1931                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelToLong"},
1932                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelToLong"},
1933                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelToLong"},
1934                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelToLong"},
1935                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelToLong"},
1936
1937                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelEmpty"},
1938                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelEmpty"},
1939                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelEmpty"},
1940                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelEmpty"},
1941                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelEmpty"},
1942                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelEmpty"},
1943                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidLabelEmpty"},
1944                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidLabelEmpty"},
1945                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidLabelEmpty"},
1946
1947                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionToLong"},
1948                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionToLong"},
1949                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionToLong"},
1950                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionToLong"},
1951                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionToLong"},
1952                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionToLong"},
1953                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionToLong"},
1954                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionToLong"},
1955                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionToLong"},
1956
1957                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionEmpty"},
1958                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionEmpty"},
1959                         {LifeCycleStatesEnum.CHECKOUT, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionEmpty"},
1960                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionEmpty"},
1961                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionEmpty"},
1962                         {LifeCycleStatesEnum.CHECKIN, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionEmpty"},
1963                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE, "updateArtifactWithInvalidDescriptionEmpty"},
1964                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.SERVICE, "updateArtifactWithInvalidDescriptionEmpty"},
1965                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, ComponentTypeEnum.RESOURCE_INSTANCE, "updateArtifactWithInvalidDescriptionEmpty"},
1966                         };
1967         }
1968
1969
1970
1971
1972         // InvalidArtifact + check audit & response code function
1973         @Test(dataProvider="updateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI")
1974         public void updateInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState,
1975                         ComponentTypeEnum componentTypeEnum, String uploadArtifactTestType) throws Exception {
1976                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, componentTypeEnum: %s, uploadArtifactTestType: %s", chosenLifeCycleState, componentTypeEnum, uploadArtifactTestType));
1977                 Component component;
1978                 ComponentInstance componentInstance = null;
1979                 String artifactType;
1980
1981                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum)     {
1982                         artifactType = ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString();
1983                         component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1984                         componentInstance = component.getComponentInstances().get(0);
1985                 } else {
1986                         artifactType = ArtifactTypeEnum.OTHER.toString();
1987                         component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
1988                 }
1989
1990                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
1991
1992                 switch (uploadArtifactTestType) {
1993                 case "updateArtifactWithInvalidCheckSum":
1994                         updateArtifactWithInvalidCheckSum(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1995                         break;
1996                 case "updateArtifactWithInvalidNameToLong":
1997                         updateArtifactWithInvalidNameToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
1998                         break;
1999                 case "updateArtifactWithInvalidNameEmpty":
2000                         updateArtifactWithInvalidNameEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2001                         break;
2002                 case "updateArtifactWithInvalidLabelToLong":
2003                         updateArtifactWithInvalidLabelToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2004                         break;
2005                 case "updateArtifactWithInvalidLabelEmpty":
2006                         updateArtifactWithInvalidLabelEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2007                         break;
2008                 case "updateArtifactWithInvalidDescriptionToLong":
2009                         updateArtifactWithInvalidDescriptionToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2010                         break;
2011                 case "updateArtifactWithInvalidDescriptionEmpty":
2012                 default:
2013                         updateArtifactWithInvalidDescriptionEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2014                         break;
2015                 }
2016
2017 ///////////////////////////////////////////////////////////////////////////////
2018 //              // TODO: there is defect when checking invalid type
2019 ////            // Upload artifact with invalid type via external API
2020 ////            // invalid type
2021 ////            String artifactType = artifactReqDetails.getArtifactType();
2022 ////            artifactReqDetails.setArtifactType("invalidType");
2023 ////            restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 400, componentResourceInstanceDetails);
2024 ////            // empty type
2025 ////            artifactReqDetails.setArtifactType("");
2026 ////            restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 400, componentResourceInstanceDetails);
2027 ////            artifactReqDetails.setArtifactType(artifactType);
2028 ///////////////////////////////////////////////////////////////////////////////
2029         }
2030
2031         // TODO
2032         // Update artifact with invalid checksum via external API
2033         protected void updateArtifactWithInvalidCheckSum(Component component, User sdncModifierDetails, String artifactType,
2034                         ComponentInstance componentInstance) throws Exception {
2035                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_INVALID_MD5.name());
2036                 List<String> variables = asList();
2037 //              uploadArtifactWithInvalidCheckSumOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2038 //                                              artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables);
2039         }
2040
2041
2042         // Update artifact with valid type & invalid name via external API - name to long
2043         protected void updateArtifactWithInvalidNameToLong(Component component, User sdncModifierDetails, String artifactType,
2044                         ComponentInstance componentInstance) throws Exception {
2045
2046                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2047                 String artifactUUID = null;
2048                 Map<String, ArtifactDefinition> deploymentArtifacts;
2049                 if(componentInstance != null) {
2050                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2051                 } else {
2052                         deploymentArtifacts = component.getDeploymentArtifacts();
2053                 }
2054
2055                 for (String key : deploymentArtifacts.keySet()) {
2056                         if (key.startsWith("ci")) {
2057                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2058                                 break;
2059                         }
2060                 }
2061
2062                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.EXCEEDS_LIMIT.name());
2063                 List<String> variables = asList("artifact name", "255");
2064                 artifactReqDetails.setArtifactName("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2065
2066                 if(componentInstance != null) {
2067                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2068                                         400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2069                 } else {
2070                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2071                                         400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2072
2073                 }
2074         }
2075
2076
2077         // Update artifact with valid type & invalid name via external API - name is empty
2078         protected void updateArtifactWithInvalidNameEmpty(Component component, User sdncModifierDetails, String artifactType,
2079                         ComponentInstance componentInstance) throws Exception {
2080
2081                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2082                 String artifactUUID = null;
2083                 Map<String, ArtifactDefinition> deploymentArtifacts;
2084                 if(componentInstance != null) {
2085                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2086                 } else {
2087                         deploymentArtifacts = component.getDeploymentArtifacts();
2088                 }
2089
2090                 for (String key : deploymentArtifacts.keySet()) {
2091                         if (key.startsWith("ci")) {
2092                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2093                                 break;
2094                         }
2095                 }
2096
2097                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_ARTIFACT_NAME.name());
2098                 List<String> variables = asList();
2099                 artifactReqDetails.setArtifactName("");
2100
2101                 if(componentInstance != null) {
2102                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2103                                         400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2104                 } else {
2105                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2106                                         400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2107
2108                 }
2109         }
2110
2111
2112         // Update artifact with valid type & invalid label via external API - label to long
2113         protected void updateArtifactWithInvalidLabelToLong(Component component, User sdncModifierDetails, String artifactType,
2114                         ComponentInstance componentInstance) throws Exception {
2115
2116                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2117                 String artifactUUID = null;
2118                 Map<String, ArtifactDefinition> deploymentArtifacts;
2119                 if(componentInstance != null) {
2120                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2121                 } else {
2122                         deploymentArtifacts = component.getDeploymentArtifacts();
2123                 }
2124
2125                 for (String key : deploymentArtifacts.keySet()) {
2126                         if (key.startsWith("ci")) {
2127                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2128                                 break;
2129                         }
2130                 }
2131
2132                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2133                 List<String> variables = asList();
2134                 artifactReqDetails.setArtifactLabel("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2135
2136                 if(componentInstance != null) {
2137                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2138                                         400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2139                 } else {
2140                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2141                                         400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2142
2143                 }
2144         }
2145
2146
2147         // Update artifact with valid type & invalid label via external API - label is empty
2148         protected void updateArtifactWithInvalidLabelEmpty(Component component, User sdncModifierDetails, String artifactType,
2149                         ComponentInstance componentInstance) throws Exception {
2150
2151                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2152                 String artifactUUID = null;
2153                 Map<String, ArtifactDefinition> deploymentArtifacts;
2154                 if(componentInstance != null) {
2155                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2156                 } else {
2157                         deploymentArtifacts = component.getDeploymentArtifacts();
2158                 }
2159
2160                 for (String key : deploymentArtifacts.keySet()) {
2161                         if (key.startsWith("ci")) {
2162                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2163                                 break;
2164                         }
2165                 }
2166
2167                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
2168                 List<String> variables = asList("artifact label");
2169                 artifactReqDetails.setArtifactLabel("");
2170
2171                 if(componentInstance != null) {
2172                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2173                                         400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2174                 } else {
2175                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2176                                         400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2177
2178                 }
2179         }
2180
2181
2182         // Update artifact with invalid description via external API - to long description
2183         protected void updateArtifactWithInvalidDescriptionToLong(Component component, User sdncModifierDetails, String artifactType,
2184                         ComponentInstance componentInstance) throws Exception {
2185
2186                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2187                 String artifactUUID = null;
2188                 Map<String, ArtifactDefinition> deploymentArtifacts;
2189                 if(componentInstance != null) {
2190                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2191                 } else {
2192                         deploymentArtifacts = component.getDeploymentArtifacts();
2193                 }
2194
2195                 for (String key : deploymentArtifacts.keySet()) {
2196                         if (key.startsWith("ci")) {
2197                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2198                                 break;
2199                         }
2200                 }
2201
2202                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2203                 List<String> variables = asList();
2204                 artifactReqDetails.setDescription("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2205
2206                 if(componentInstance != null) {
2207                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2208                                         400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2209                 } else {
2210                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2211                                         400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2212
2213                 }
2214         }
2215
2216
2217         // Update artifact with invalid description via external API - empty description
2218         protected void updateArtifactWithInvalidDescriptionEmpty(Component component, User sdncModifierDetails, String artifactType,
2219                         ComponentInstance componentInstance) throws Exception {
2220
2221                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2222                 String artifactUUID = null;
2223                 Map<String, ArtifactDefinition> deploymentArtifacts;
2224                 if(componentInstance != null) {
2225                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2226                 } else {
2227                         deploymentArtifacts = component.getDeploymentArtifacts();
2228                 }
2229
2230                 for (String key : deploymentArtifacts.keySet()) {
2231                         if (key.startsWith("ci")) {
2232                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2233                                 break;
2234                         }
2235                 }
2236
2237
2238                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2239                 List<String> variables = asList("artifact description");
2240                 artifactReqDetails.setDescription("");
2241
2242                 if(componentInstance != null) {
2243                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2244                                         400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2245                 } else {
2246                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2247                                         400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null, true);
2248
2249                 }
2250         }
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260         // Unhappy flow - get chosen life cycle state, artifact type and asset type
2261         // update artifact via external API + check audit & response code
2262         // Download artifact via external API + check audit & response code
2263         // Check artifact version, uuid & checksusm
2264         protected Component updateArtifactOnAssetViaExternalAPI(Component component, ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ErrorInfo errorInfo, List<String> variables, UserRoleEnum userRoleEnum, Integer expectedResponseCode) throws Exception {
2265                 String componentVersionBeforeUpdate = null;
2266
2267                 // get updated artifact data
2268                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
2269                 componentVersionBeforeUpdate = component.getVersion();
2270
2271                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2272                 ArtifactReqDetails artifactReqDetails = getUpdatedArtifact(deploymentArtifacts, artifactType);
2273
2274                 String artifactName = artifactReqDetails.getArtifactLabel();
2275                 String artifactUUID = deploymentArtifacts.get(artifactName).getArtifactUUID();
2276                 String artifactVersionBeforeUpdate = deploymentArtifacts.get(artifactName).getArtifactVersion();
2277                 int numberOfArtifact = deploymentArtifacts.size();
2278
2279                 // create component/s & upload artifact via external api
2280                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2281                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2282                                         expectedResponseCode, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, chosenLifeCycleState, true);
2283                 } else {
2284                         updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2285                                         expectedResponseCode, null, artifactReqDetails, artifactUUID, errorInfo, variables, chosenLifeCycleState, true);
2286                 }
2287
2288                 if(component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
2289                         component = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
2290                 } else {
2291                         component = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
2292                 }
2293
2294                 // Get list of deployment artifact + download them via external API
2295                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2296                         deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2297                 } else {
2298                         deploymentArtifacts = component.getDeploymentArtifacts();
2299                 }
2300                 Assert.assertEquals(numberOfArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will be same as before.");
2301                 Assert.assertEquals(String.valueOf((Integer.parseInt(artifactVersionBeforeUpdate))), deploymentArtifacts.get(artifactName).getArtifactVersion(), "Expected that aftifact will not change.");
2302                 Assert.assertEquals(artifactUUID, deploymentArtifacts.get(artifactName).getArtifactUUID(), "Expected that aftifactUUID will not change.");
2303                 Assert.assertEquals(componentVersionBeforeUpdate, component.getVersion(), "Expected that check-out component will not change version number.");
2304
2305                 return component;
2306         }
2307
2308         protected RestResponse updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, User sdncModifierDetails,
2309                         Integer expectedResponseCode, ComponentInstance componentInstance, ArtifactReqDetails artifactReqDetails, String artifactUUID, ErrorInfo errorInfo, List<String> variables, LifeCycleStatesEnum lifeCycleStatesEnum, Boolean resourceNameInAudit) throws Exception {
2310                 RestResponse restResponse;
2311
2312                 if(componentInstance != null) {
2313                         restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfComponentInstanceOnAsset(resourceDetails, sdncModifierDetails, artifactReqDetails, componentInstance, artifactUUID);
2314                 } else {
2315                         restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfTheAsset(resourceDetails, sdncModifierDetails, artifactReqDetails, artifactUUID);
2316
2317                 }
2318
2319                 // validate response code
2320                 Integer responseCode = restResponse.getErrorCode();
2321                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2322
2323                 //TODO
2324                 // Check auditing for upload operation
2325                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2326
2327                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2328
2329                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
2330 //              ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
2331
2332                 responseArtifact.setUpdaterFullName("");
2333                 responseArtifact.setUserIdLastUpdater(sdncModifierDetails.getUserId());
2334                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditFailure(assetTypeEnum, action, responseArtifact, resourceDetails.getUUID(), errorInfo, variables);
2335                 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getName());
2336                 expectedExternalAudit.setRESOURCE_TYPE(resourceDetails.getComponentType().getValue());
2337                 expectedExternalAudit.setARTIFACT_DATA("");
2338                 expectedExternalAudit.setCURR_ARTIFACT_UUID(artifactUUID);
2339                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2340                 body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
2341                 if(componentInstance != null) {
2342                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getComponentInstances().get(0).getNormalizedName());
2343                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts/" + artifactUUID);
2344                         expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
2345                 } else {
2346                         expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL() + "/" + artifactUUID);
2347                         if((lifeCycleStatesEnum == LifeCycleStatesEnum.CHECKIN) || (lifeCycleStatesEnum == LifeCycleStatesEnum.STARTCERTIFICATION)) {
2348                                 if(resourceNameInAudit) {
2349                                         expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getName());
2350                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
2351                                 } else {
2352                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
2353 //                                      body.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, artifactUUID);
2354                                         expectedExternalAudit.setRESOURCE_NAME("");
2355                                 }
2356                         } else {
2357                                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
2358                         }
2359                 }
2360
2361
2362                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2363                 return restResponse;
2364
2365         }
2366
2367
2368         // This function get component, user & if updatedPayload or not
2369         // It will create default payload / updated payload of artifact
2370         // And download artifact of component which starts with ci
2371         protected RestResponse downloadResourceDeploymentArtifactExternalAPIAndComparePayLoadOfArtifactType(Component component, String artifactType, User sdncModifierDetails, ComponentTypeEnum componentTypeEnum) throws IOException, Exception {
2372                 // Download the uploaded artifact via external API
2373                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("abcd", artifactType, true, false);
2374                 String artifactName = null;
2375                 for (String key : component.getDeploymentArtifacts().keySet()) {
2376                         if (key.startsWith("ci")) {
2377                                 artifactName = key;
2378                                 break;
2379                         }
2380                 }
2381                 return downloadResourceDeploymentArtifactExternalAPI(component, component.getDeploymentArtifacts().get(artifactName), sdncModifierDetails, artifactReqDetails, componentTypeEnum);
2382         }
2383
2384         // Get deployment artifact of asset
2385         protected Map<String, ArtifactDefinition> getDeploymentArtifactsOfAsset(Component component, ComponentTypeEnum componentTypeEnum) {
2386                 Map<String, ArtifactDefinition> deploymentArtifacts = null;
2387                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2388                         for(ComponentInstance componentInstance: component.getComponentInstances()) {
2389                                 if(componentInstance.getNormalizedName().startsWith("ci")) {
2390                                         deploymentArtifacts = componentInstance.getDeploymentArtifacts();
2391                                         break;
2392                                 }
2393                         }
2394                 } else {
2395                         deploymentArtifacts = component.getDeploymentArtifacts();
2396                 }
2397                 return deploymentArtifacts;
2398         }
2399
2400         // get deploymentArtifact of asset and artifactType -> generate new artifact that can be updated on the asset
2401         protected ArtifactReqDetails getUpdatedArtifact(Map<String, ArtifactDefinition> deploymentArtifacts, String artifactType) throws IOException, Exception {
2402                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2403
2404                 for (String key : deploymentArtifacts.keySet()) {
2405                         if (key.startsWith("ci")) {
2406                                 artifactReqDetails.setArtifactDisplayName(deploymentArtifacts.get(key).getArtifactDisplayName());
2407                                 artifactReqDetails.setArtifactName(deploymentArtifacts.get(key).getArtifactName());
2408                                 artifactReqDetails.setArtifactLabel(deploymentArtifacts.get(key).getArtifactLabel());
2409                                 break;
2410                         }
2411                 }
2412
2413                 return artifactReqDetails;
2414         }
2415
2416         // Happy flow - get chosen life cycle state, artifact type and asset type
2417         // update artifact via external API + check audit & response code
2418         // Download artifact via external API + check audit & response code
2419         // Check artifact version, uuid & checksusm
2420         protected Component updateArtifactOnAssetViaExternalAPI(Component component, ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState, String artifactType) throws Exception {
2421                 RestResponse restResponse = null;
2422                 int numberOfArtifact = 0;
2423                 String artifactVersionBeforeUpdate = null;
2424                 String artifactName = null;
2425                 String componentVersionBeforeUpdate = null;
2426
2427                 // get updated artifact data
2428                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, true);
2429                 String artifactUUID = null;
2430                 Map<String, ArtifactDefinition> deploymentArtifacts;
2431                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2432
2433                 for (String key : deploymentArtifacts.keySet()) {
2434                         if (key.startsWith("ci")) {
2435                                 artifactName = key;
2436                                 artifactVersionBeforeUpdate = deploymentArtifacts.get(key).getArtifactVersion();
2437                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2438                                 artifactReqDetails.setArtifactDisplayName(deploymentArtifacts.get(key).getArtifactDisplayName());
2439                                 artifactReqDetails.setArtifactName(deploymentArtifacts.get(key).getArtifactName());
2440                                 artifactReqDetails.setArtifactLabel(deploymentArtifacts.get(key).getArtifactLabel());
2441                                 break;
2442                         }
2443                 }
2444
2445                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
2446                 componentVersionBeforeUpdate = component.getVersion();
2447                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2448                 numberOfArtifact = deploymentArtifacts.size();
2449
2450
2451                 // create component/s & upload artifact via external api
2452                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2453                         if((chosenLifeCycleState == LifeCycleStatesEnum.CERTIFICATIONREQUEST) && (!component.getComponentType().toString().equals(ComponentTypeEnum.RESOURCE.toString()))) {
2454                                 numberOfArtifact = numberOfArtifact - 1;
2455                         }
2456                         restResponse = updateArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID, 200);
2457                 } else {
2458
2459                         restResponse = updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID, 200);
2460                 }
2461
2462
2463
2464                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2465                 component = getNewerVersionOfComponent(component, chosenLifeCycleState);
2466
2467                 // Get list of deployment artifact + download them via external API
2468                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2469                 Assert.assertEquals(numberOfArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will be same as before.");
2470                 Assert.assertEquals(String.valueOf((Integer.parseInt(artifactVersionBeforeUpdate) + 1)), deploymentArtifacts.get(artifactName).getArtifactVersion(), "Expected that aftifact version will increase by one.");
2471
2472                 if(chosenLifeCycleState == LifeCycleStatesEnum.CHECKOUT) {
2473                         Assert.assertEquals(componentVersionBeforeUpdate, component.getVersion(), "Expected that check-out component will not change version number.");
2474                 } else {
2475                         Assert.assertEquals(String.format("%.1f", (Double.parseDouble(componentVersionBeforeUpdate) + 0.1)), component.getVersion(), "Expected that non check-out component version will increase by 0.1.");
2476                 }
2477
2478                 // Download the uploaded artifact via external API
2479                 downloadResourceDeploymentArtifactExternalAPI(component, deploymentArtifacts.get(responseArtifact.getArtifactLabel()), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentTypeEnum);
2480
2481                 return component;
2482         }
2483
2484
2485         // Update artifact via external API + Check auditing for upload operation + Check response of external API
2486         protected RestResponse updateArtifactOfRIIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, ComponentInstance componentInstance, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
2487                 RestResponse restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfComponentInstanceOnAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, resourceDetails.getComponentInstances().get(0), artifactUUID);
2488
2489                 // Check response of external API
2490                 Integer responseCode = restResponse.getErrorCode();
2491                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2492
2493
2494                 // Check auditing for upload operation
2495                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2496
2497                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2498
2499                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2500                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
2501
2502                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
2503                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
2504 //              expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
2505                 expectedExternalAudit.setRESOURCE_NAME(componentInstance.getNormalizedName());
2506                 expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts/" + artifactUUID);
2507                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2508
2509                 return restResponse;
2510         }
2511
2512
2513         // Update artifact via external API + Check auditing for upload operation + Check response of external API
2514         protected RestResponse updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
2515                 RestResponse restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfTheAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID);
2516
2517                 // Check response of external API
2518                 Integer responseCode = restResponse.getErrorCode();
2519                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2520
2521
2522                 // Check auditing for upload operation
2523                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2524
2525                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2526
2527                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2528                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
2529
2530                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
2531                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
2532                 expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
2533                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2534
2535                 return restResponse;
2536         }
2537
2538
2539
2540
2541         ////////////////////////////////////////////////////////////////////////////////////
2542         ////////////////////////////////////////////////////////////////////////////////////
2543         ////////////////////////////////////////////////////////////////////////////////////
2544         //                                      Delete External API                                                                                       //
2545         ////////////////////////////////////////////////////////////////////////////////////
2546         ////////////////////////////////////////////////////////////////////////////////////
2547         ////////////////////////////////////////////////////////////////////////////////////
2548         @DataProvider(name="deleteArtifactForServiceViaExternalAPI", parallel=false)
2549         public static Object[][] dataProviderDeleteArtifactForServiceViaExternalAPI() {
2550                 return new Object[][] {
2551                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
2552                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
2553                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
2554                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
2555                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2556                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
2557                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
2558                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
2559                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
2560                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
2561                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
2562                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
2563                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
2564                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
2565                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"},
2566                         {LifeCycleStatesEnum.CERTIFY, "YANG_XML"},
2567                         {LifeCycleStatesEnum.CERTIFY, "VNF_CATALOG"},
2568                         {LifeCycleStatesEnum.CERTIFY, "MODEL_INVENTORY_PROFILE"},
2569                         {LifeCycleStatesEnum.CERTIFY, "MODEL_QUERY_SPEC"},
2570                         {LifeCycleStatesEnum.CERTIFY, "OTHER"}
2571                         };
2572         }
2573
2574
2575
2576
2577         // Delete artifact for Service - Success
2578         @Test(dataProvider="deleteArtifactForServiceViaExternalAPI")
2579         public void deleteArtifactForServiceViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
2580                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s", lifeCycleStatesEnum, artifactType));
2581                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.SERVICE, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
2582                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.SERVICE, lifeCycleStatesEnum);
2583         }
2584
2585         @DataProvider(name="deleteArtifactForVFViaExternalAPI", parallel=false)
2586         public static Object[][] dataProviderDeleteArtifactForVFViaExternalAPI() {
2587                 return new Object[][] {
2588                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_JSON"},
2589                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_POLICY"},
2590                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_EVENT"},
2591                         {LifeCycleStatesEnum.CHECKOUT, "APPC_CONFIG"},
2592                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_DOC"},
2593                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_TOSCA"},
2594                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
2595                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG"},
2596                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE"},
2597                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE"},
2598                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE"},
2599                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC"},
2600                         {LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2601
2602                         {LifeCycleStatesEnum.CHECKIN, "DCAE_JSON"},
2603                         {LifeCycleStatesEnum.CHECKIN, "DCAE_POLICY"},
2604                         {LifeCycleStatesEnum.CHECKIN, "DCAE_EVENT"},
2605                         {LifeCycleStatesEnum.CHECKIN, "APPC_CONFIG"},
2606                         {LifeCycleStatesEnum.CHECKIN, "DCAE_DOC"},
2607                         {LifeCycleStatesEnum.CHECKIN, "DCAE_TOSCA"},
2608                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML"},
2609                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG"},
2610                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE"},
2611                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE"},
2612                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE"},
2613                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC"},
2614                         {LifeCycleStatesEnum.CHECKIN, "OTHER"},
2615
2616                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_JSON"},
2617                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_POLICY"},
2618                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_EVENT"},
2619                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "APPC_CONFIG"},
2620                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_DOC"},
2621                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_TOSCA"},
2622                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML"},
2623                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG"},
2624                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE"},
2625                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE"},
2626                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE"},
2627                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC"},
2628                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER"},
2629                         };
2630         }
2631
2632
2633         // Delete artifact for VF - Success
2634         @Test(dataProvider="deleteArtifactForVFViaExternalAPI")
2635         public void deleteArtifactForVFViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
2636                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s", lifeCycleStatesEnum, artifactType));
2637                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
2638                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE, lifeCycleStatesEnum);
2639         }
2640
2641         @DataProvider(name="deleteArtifactForVfcVlCpViaExternalAPI", parallel=false)
2642         public static Object[][] dataProviderDeleteArtifactForVfcVlCpViaExternalAPI() {
2643                 return new Object[][] {
2644                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VFC},
2645                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VFC},
2646                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VFC},
2647                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
2648                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
2649                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
2650                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VFC},
2651                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
2652                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
2653
2654                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.VL},
2655                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.VL},
2656                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.VL},
2657                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.VL},
2658                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
2659                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
2660                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.VL},
2661                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
2662                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
2663
2664                         {LifeCycleStatesEnum.CHECKOUT, "YANG_XML", ResourceTypeEnum.CP},
2665                         {LifeCycleStatesEnum.CHECKOUT, "VNF_CATALOG", ResourceTypeEnum.CP},
2666                         {LifeCycleStatesEnum.CHECKOUT, "VF_LICENSE", ResourceTypeEnum.CP},
2667                         {LifeCycleStatesEnum.CHECKOUT, "VENDOR_LICENSE", ResourceTypeEnum.CP},
2668                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
2669                         {LifeCycleStatesEnum.CHECKOUT, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
2670                         {LifeCycleStatesEnum.CHECKOUT, "OTHER", ResourceTypeEnum.CP},
2671                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
2672                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
2673
2674                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VFC},
2675                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VFC},
2676                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VFC},
2677                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
2678                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
2679                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
2680                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VFC},
2681                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
2682                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
2683
2684                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.VL},
2685                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.VL},
2686                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.VL},
2687                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.VL},
2688                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
2689                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
2690                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.VL},
2691                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
2692                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
2693
2694                         {LifeCycleStatesEnum.CHECKIN, "YANG_XML", ResourceTypeEnum.CP},
2695                         {LifeCycleStatesEnum.CHECKIN, "VNF_CATALOG", ResourceTypeEnum.CP},
2696                         {LifeCycleStatesEnum.CHECKIN, "VF_LICENSE", ResourceTypeEnum.CP},
2697                         {LifeCycleStatesEnum.CHECKIN, "VENDOR_LICENSE", ResourceTypeEnum.CP},
2698                         {LifeCycleStatesEnum.CHECKIN, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
2699                         {LifeCycleStatesEnum.CHECKIN, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
2700                         {LifeCycleStatesEnum.CHECKIN, "OTHER", ResourceTypeEnum.CP},
2701                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
2702                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
2703
2704                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VFC},
2705                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VFC},
2706                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VFC},
2707                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VFC},
2708                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VFC},
2709                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VFC},
2710                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VFC},
2711                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
2712                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
2713
2714                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.VL},
2715                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.VL},
2716                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.VL},
2717                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.VL},
2718                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.VL},
2719                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.VL},
2720                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.VL},
2721                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
2722                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
2723
2724                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "YANG_XML", ResourceTypeEnum.CP},
2725                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VNF_CATALOG", ResourceTypeEnum.CP},
2726                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VF_LICENSE", ResourceTypeEnum.CP},
2727                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "VENDOR_LICENSE", ResourceTypeEnum.CP},
2728                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_INVENTORY_PROFILE", ResourceTypeEnum.CP},
2729                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "MODEL_QUERY_SPEC", ResourceTypeEnum.CP},
2730                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "OTHER", ResourceTypeEnum.CP},
2731                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
2732                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
2733                         };
2734         }
2735
2736
2737         // Delete artifact for VFC, VL, CP - Success
2738         @Test(dataProvider="deleteArtifactForVfcVlCpViaExternalAPI")
2739         public void deleteArtifactForVfcVlCpViaExternalAPI(LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2740                 getExtendTest().log(Status.INFO, String.format("lifeCycleStatesEnum: %s, artifactType: %s, resourceTypeEnum: %s", lifeCycleStatesEnum, artifactType, resourceTypeEnum));
2741                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
2742                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE, lifeCycleStatesEnum);
2743         }
2744
2745         @DataProvider(name="deleteArtifactOnRIViaExternalAPI", parallel=false)
2746         public static Object[][] dataProviderDeleteArtifactOnRIViaExternalAPI() {
2747                 return new Object[][] {
2748                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", null},
2749                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", null},
2750                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", null},
2751                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", null},
2752                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", null},
2753                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", null},
2754
2755                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", null},
2756                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", null},
2757                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", null},
2758                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", null},
2759                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", null},
2760                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", null},
2761
2762                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
2763                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VF},
2764                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VF},
2765                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VF},
2766                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VF},
2767                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VF}
2768
2769                         };
2770         }
2771
2772
2773
2774
2775
2776         @Test(dataProvider="deleteArtifactOnRIViaExternalAPI")
2777         public void deleteArtifactOnRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2778                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
2779                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
2780                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState);
2781         }
2782
2783
2784         @DataProvider(name="deleteArtifactOnVfcVlCpRIViaExternalAPI", parallel=false)
2785         public static Object[][] dataProviderDeleteArtifactOnVfcVlCpRIViaExternalAPI() {
2786                 return new Object[][] {
2787                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
2788                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
2789                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
2790                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
2791                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
2792                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
2793                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VFC},
2794                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VFC},
2795
2796
2797                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
2798                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
2799                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
2800                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
2801                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
2802                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
2803                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.VL},
2804                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.VL},
2805
2806                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
2807                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP,},
2808                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
2809                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
2810                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
2811                         {LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
2812                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_POLL", ResourceTypeEnum.CP},
2813                         {LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", ResourceTypeEnum.CP},
2814
2815
2816                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
2817                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
2818                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
2819                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
2820                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
2821                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
2822                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VFC},
2823                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VFC},
2824
2825                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
2826                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
2827                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
2828                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
2829                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
2830                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
2831                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.VL},
2832                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.VL},
2833
2834                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
2835                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
2836                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
2837                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
2838                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
2839                         {LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
2840                         {LifeCycleStatesEnum.CHECKIN, "SNMP_POLL", ResourceTypeEnum.CP},
2841                         {LifeCycleStatesEnum.CHECKIN, "SNMP_TRAP", ResourceTypeEnum.CP},
2842
2843                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VFC},
2844                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VFC},
2845                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VFC},
2846                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VFC},
2847                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VFC},
2848                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VFC},
2849                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VFC},
2850                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VFC},
2851
2852                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VL},
2853                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.VL},
2854                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.VL},
2855                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.VL},
2856                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.VL},
2857                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.VL},
2858                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.VL},
2859                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.VL},
2860
2861                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.CP},
2862                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_JSON", ResourceTypeEnum.CP},
2863                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_POLICY", ResourceTypeEnum.CP},
2864                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_DOC", ResourceTypeEnum.CP},
2865                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_BLUEPRINT", ResourceTypeEnum.CP},
2866                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "DCAE_INVENTORY_EVENT", ResourceTypeEnum.CP},
2867                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_POLL", ResourceTypeEnum.CP},
2868                         {LifeCycleStatesEnum.CERTIFICATIONREQUEST, "SNMP_TRAP", ResourceTypeEnum.CP}
2869
2870                         };
2871         }
2872
2873
2874
2875
2876
2877         @Test(dataProvider="deleteArtifactOnVfcVlCpRIViaExternalAPI")
2878         public void deleteArtifactOnVfcVlCpRIViaExternalAPI(LifeCycleStatesEnum chosenLifeCycleState, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2879                 getExtendTest().log(Status.INFO, String.format("chosenLifeCycleState: %s, artifactType: %s", chosenLifeCycleState, artifactType));
2880                 Component component = uploadArtifactOnAssetViaExternalAPI(ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, artifactType, resourceTypeEnum);
2881                 deleteArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, chosenLifeCycleState);
2882         }
2883
2884
2885         @DataProvider(name="deleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset", parallel=false)
2886         public static Object[][] dataProviderDeleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset() {
2887                 return new Object[][] {
2888                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2889                         {ComponentTypeEnum.SERVICE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2890                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.DESIGNER2, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2891
2892                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2893                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2894                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2895                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2896                         {ComponentTypeEnum.SERVICE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2897                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.TESTER, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2898
2899                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2900                         {ComponentTypeEnum.SERVICE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2901                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2902                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2903                         {ComponentTypeEnum.SERVICE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2904                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.ADMIN, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2905
2906                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2907                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2908                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2909                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2910                         {ComponentTypeEnum.SERVICE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2911                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.OPS, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2912 //
2913                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2914                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2915                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2916                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2917                         {ComponentTypeEnum.SERVICE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2918                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.GOVERNOR, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2919
2920                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2921                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2922                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2923                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2924                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2925                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_STRATEGIST1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2926
2927                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2928                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "OTHER"},
2929                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKIN, "DCAE_INVENTORY_TOSCA"},
2930                         {ComponentTypeEnum.RESOURCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2931                         {ComponentTypeEnum.SERVICE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "OTHER"},
2932                         {ComponentTypeEnum.RESOURCE_INSTANCE, UserRoleEnum.PRODUCT_MANAGER1, LifeCycleStatesEnum.CHECKOUT, "DCAE_INVENTORY_TOSCA"},
2933                         };
2934         }
2935
2936
2937         // External API
2938         // Delete artifact by diffrent user then creator of asset - Fail
2939         @Test(dataProvider="deleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset")
2940         public void deleteArtifactOnVFViaExternalAPIByDiffrentUserThenCreatorOfAsset(ComponentTypeEnum componentTypeEnum, UserRoleEnum userRoleEnum, LifeCycleStatesEnum lifeCycleStatesEnum, String artifactType) throws Exception {
2941                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, userRoleEnum %s, lifeCycleStatesEnum %s, artifactType: %s", componentTypeEnum, userRoleEnum, lifeCycleStatesEnum, artifactType));
2942                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, lifeCycleStatesEnum, artifactType, null);
2943                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2944
2945                 String artifactUUID = null;
2946                 for (String key : deploymentArtifacts.keySet()) {
2947                         if (key.startsWith("ci")) {
2948                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2949                                 break;
2950                         }
2951                 }
2952
2953                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
2954                 List<String> variables = asList();
2955
2956                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
2957                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2958                                         409, component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, lifeCycleStatesEnum, true);
2959                 } else {
2960                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2961                                         409, null, artifactUUID, errorInfo, variables, lifeCycleStatesEnum, true);
2962                 }
2963
2964                 //TODO
2965 //              downloadResourceDeploymentArtifactExternalAPI(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, componentTypeEnum);
2966         }
2967
2968
2969         @DataProvider(name="deleteArtifactOnAssetWhichNotExist", parallel=false)
2970         public static Object[][] dataProviderDeleteArtifactOnAssetWhichNotExist() {
2971                 return new Object[][] {
2972                         {ComponentTypeEnum.SERVICE, "OTHER", null},
2973                         {ComponentTypeEnum.RESOURCE, "OTHER", null},
2974                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA", ResourceTypeEnum.VF},
2975                         };
2976         }
2977
2978
2979         // External API
2980         // Upload artifact on VF via external API - happy flow
2981         @Test(dataProvider="deleteArtifactOnAssetWhichNotExist")
2982         public void deleteArtifactOnAssetWhichNotExist(ComponentTypeEnum componentTypeEnum, String artifactType, ResourceTypeEnum resourceTypeEnum) throws Exception {
2983                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
2984                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, resourceTypeEnum);
2985
2986                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2987
2988                 String artifactUUID = null;
2989                 for (String key : deploymentArtifacts.keySet()) {
2990                         if (key.startsWith("ci")) {
2991                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2992                                 break;
2993                         }
2994                 }
2995
2996                 // Invalid artifactUUID
2997                 String invalidArtifactUUID = "12341234-1234-1234-1234-123412341234";
2998                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
2999                 List<String> variables = asList(invalidArtifactUUID);
3000
3001                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
3002                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3003                                         404, component.getComponentInstances().get(0), invalidArtifactUUID, errorInfo, variables, null, true);
3004                 } else {
3005                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3006                                         404, null, invalidArtifactUUID, errorInfo, variables, null, true);
3007
3008                 }
3009
3010
3011                 // Invalid componentUUID
3012                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
3013                         component.getComponentInstances().get(0).setNormalizedName("invalidNormalizedName");
3014                         errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER.name());
3015                         variables = asList("invalidNormalizedName", ComponentTypeEnum.RESOURCE_INSTANCE.getValue().toLowerCase(), ComponentTypeEnum.SERVICE.getValue(), component.getName());
3016                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3017                                         404, component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, true);
3018                 } else {
3019                         component.setUUID("invalidComponentUUID");
3020                         if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE)) {
3021                                 errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
3022                         } else {
3023                                 errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.SERVICE_NOT_FOUND.name());
3024                         }
3025                         variables = asList("invalidComponentUUID");
3026                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3027                                         404, null, artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN, false);
3028                 }
3029
3030
3031 //              performeClean();
3032
3033         }
3034
3035         @DataProvider(name="deleteArtifactOnAssetWhichInInvalidStateForUploading", parallel=false)
3036         public static Object[][] dataProviderDeleteArtifactOnAssetWhichInInvalidStateForUploading() {
3037                 return new Object[][] {
3038                         {ComponentTypeEnum.SERVICE, "OTHER"},
3039                         {ComponentTypeEnum.RESOURCE, "OTHER"},
3040                         {ComponentTypeEnum.RESOURCE_INSTANCE, "DCAE_INVENTORY_TOSCA"},
3041                         };
3042         }
3043
3044
3045         @Test(dataProvider="deleteArtifactOnAssetWhichInInvalidStateForUploading")
3046         public void deleteArtifactOnAssetWhichInInvalidStateForUploading(ComponentTypeEnum componentTypeEnum, String artifactType) throws Exception {
3047                 getExtendTest().log(Status.INFO, String.format("componentTypeEnum: %s, artifactType: %s", componentTypeEnum, artifactType));
3048                 Component component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKOUT, artifactType, null);
3049                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.STARTCERTIFICATION, true).getLeft();
3050
3051                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
3052                 String artifactUUID = null;
3053                 for (String key : deploymentArtifacts.keySet()) {
3054                         if (key.startsWith("ci")) {
3055                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
3056                                 break;
3057                         }
3058                 }
3059
3060
3061                 // Invalid artifactUUID
3062                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name());
3063                 List<String> variables = asList(component.getName(), component.getComponentType().toString().toLowerCase(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getFirstName(),
3064                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getLastName(), ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId());
3065
3066                 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
3067                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3068                                         403, component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, null, true);
3069                 } else {
3070                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3071                                         403, null, artifactUUID, errorInfo, variables, null, true);
3072
3073                 }
3074
3075         }
3076
3077
3078         @DataProvider(name="deleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI", parallel=false)
3079         public static Object[][] dataProviderDeleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI() {
3080                 return new Object[][] {
3081                         {ResourceTypeEnum.VFC},
3082                         {ResourceTypeEnum.VL},
3083                         {ResourceTypeEnum.CP}
3084                         };
3085         }
3086
3087
3088         // Verify that it cannot delete VFC/VL/CP artifact on VFCi/VLi/CPi - Failure flow
3089         @Test(dataProvider="deleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI")
3090         public void deleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI(ResourceTypeEnum resourceTypeEnum) throws Exception {
3091                 getExtendTest().log(Status.INFO, String.format("resourceTypeEnum: %s", resourceTypeEnum));
3092
3093                 Component resourceInstanceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.getValue(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, resourceTypeEnum);
3094                 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", "SNMP_TRAP", true, false);
3095                 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceInstanceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
3096                 resourceInstanceDetails = AtomicOperationUtils.changeComponentState(resourceInstanceDetails, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
3097                 Component component = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
3098                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceInstanceDetails, component, UserRoleEnum.DESIGNER, true).left().value();
3099                 component = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
3100
3101                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name());
3102                 Map<String, ArtifactDefinition> deploymentArtifacts;
3103                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, ComponentTypeEnum.RESOURCE_INSTANCE);
3104                 String artifactUUID = null;
3105                 for (String key : deploymentArtifacts.keySet()) {
3106                         if (key.startsWith("ci")) {
3107                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
3108                                 break;
3109                         }
3110                 }
3111                 List<String> variables = asList(artifactUUID);
3112                 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3113                                 404, component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, null, true);
3114         }
3115
3116         protected RestResponse deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, User sdncModifierDetails,
3117                         Integer expectedResponseCode, ComponentInstance componentInstance, String artifactUUID, ErrorInfo errorInfo, List<String> variables, LifeCycleStatesEnum lifeCycleStatesEnum, Boolean resourceNameInAudit) throws Exception {
3118                 RestResponse restResponse;
3119
3120                 if(componentInstance != null) {
3121                         restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfComponentInstanceOnAsset(resourceDetails, sdncModifierDetails, componentInstance, artifactUUID);
3122                 } else {
3123                         restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfTheAsset(resourceDetails, sdncModifierDetails, artifactUUID);
3124
3125                 }
3126
3127                 // validate response code
3128                 Integer responseCode = restResponse.getErrorCode();
3129                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3130
3131                 // Check auditing for upload operation
3132                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3133
3134                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3135
3136                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
3137 //              ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
3138
3139                 responseArtifact.setUpdaterFullName("");
3140                 responseArtifact.setUserIdLastUpdater(sdncModifierDetails.getUserId());
3141                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditFailure(assetTypeEnum, action, responseArtifact, resourceDetails.getUUID(), errorInfo, variables);
3142                 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getName());
3143                 expectedExternalAudit.setRESOURCE_TYPE(resourceDetails.getComponentType().getValue());
3144                 expectedExternalAudit.setARTIFACT_DATA(null);
3145                 expectedExternalAudit.setCURR_ARTIFACT_UUID(artifactUUID);
3146                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3147                 body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
3148                 if(componentInstance != null) {
3149                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getComponentInstances().get(0).getNormalizedName());
3150                         expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts/" + artifactUUID);
3151                         expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
3152                 } else {
3153                         expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL() + "/" + artifactUUID);
3154                         if((errorInfo.getMessageId().equals(ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name()).getMessageId())) ||
3155                                         errorInfo.getMessageId().equals(ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_IN_CERT_IN_PROGRESS_STATE.name()).getMessageId()) ||
3156                                         (lifeCycleStatesEnum == LifeCycleStatesEnum.STARTCERTIFICATION)) {
3157                                 if(resourceNameInAudit) {
3158                                         expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getName());
3159                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
3160                                 } else {
3161                                         expectedExternalAudit.setRESOURCE_NAME("");
3162                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
3163                                 }
3164                         } else {
3165                                 if(resourceNameInAudit) {
3166                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
3167                                 } else {
3168                                         expectedExternalAudit.setRESOURCE_NAME("");
3169                                         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
3170                                 }
3171                         }
3172                 }
3173
3174 //              getExtendTest().log(LogStatus.INFO, "Audit Action: " + AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName());
3175 //              body.forEach((k,v)->getExtendTest().log(LogStatus.INFO,"key : " + k + " value : " + v));
3176                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3177
3178                 return restResponse;
3179
3180         }
3181
3182
3183         // Happy flow - get chosen life cycle state, artifact type and asset type
3184         // delete artifact via external API + check audit & response code
3185         protected Component deleteArtifactOnAssetViaExternalAPI(Component component, ComponentTypeEnum componentTypeEnum, LifeCycleStatesEnum chosenLifeCycleState) throws Exception {
3186                 String artifactName = null;
3187                 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
3188
3189                 // get updated artifact data
3190                 String artifactUUID = null;
3191                 int moduleTypeArtifact = 0;
3192                 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
3193
3194                 for (String key : deploymentArtifacts.keySet()) {
3195                         if (key.startsWith("ci")  && StringUtils.isNotEmpty(deploymentArtifacts.get(key).getArtifactUUID())) {
3196                                 artifactName = key;
3197                                 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
3198
3199                                 if (deploymentArtifacts.get(key).getArtifactType().equals(ArtifactTypeEnum.VF_MODULES_METADATA)){
3200                                         moduleTypeArtifact = 1;
3201                                 }
3202                                 break;
3203                         }
3204                 }
3205
3206
3207                 String componentVersionBeforeDelete = component.getVersion();
3208                 int numberOfArtifact = deploymentArtifacts.size();
3209
3210
3211
3212                 // create component/s & upload artifact via external api
3213                 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
3214                         deleteArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, 200);
3215                 } else {
3216                         deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, 200);
3217                 }
3218
3219                 component = getNewerVersionOfComponent(component, chosenLifeCycleState);
3220
3221                 // Get list of deployment artifact + download them via external API
3222                 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
3223                 if(deploymentArtifacts.get(artifactName) != null) {
3224                         Assert.assertTrue(false, "Expected that deleted artifact will not appear in deployment artifact list.");
3225                 }
3226                 if((LifeCycleStatesEnum.CERTIFICATIONREQUEST.equals(chosenLifeCycleState)) && (ComponentTypeEnum.RESOURCE_INSTANCE.equals(componentTypeEnum)) && (!component.getComponentType().toString().equals(ComponentTypeEnum.RESOURCE.toString()))) {
3227                         Assert.assertEquals(numberOfArtifact - 1 - moduleTypeArtifact, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact (one deleted and one vfmodule) will decrease by two.");
3228                 } else {
3229                         Assert.assertEquals(numberOfArtifact - 1, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will decrease by one.");
3230                 }
3231
3232
3233                 if(chosenLifeCycleState == LifeCycleStatesEnum.CHECKOUT) {
3234                         Assert.assertEquals(componentVersionBeforeDelete, component.getVersion(), "Expected that check-out component will not change version number.");
3235                 } else {
3236                         Assert.assertEquals(String.format("%.1f", (Double.parseDouble(componentVersionBeforeDelete) + 0.1)), component.getVersion(), "Expected that non check-out component version will increase by 0.1.");
3237                 }
3238
3239                 downloadResourceDeploymentArtifactExternalAPI(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, componentTypeEnum);
3240
3241                 return component;
3242         }
3243
3244         // Delete artifact via external API + Check auditing for upload operation + Check response of external API
3245         protected RestResponse deleteArtifactOfRIIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, ComponentInstance componentInstance, User sdncModifierDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
3246                 RestResponse restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfComponentInstanceOnAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getComponentInstances().get(0), artifactUUID);
3247
3248                 // Check response of external API
3249                 Integer responseCode = restResponse.getErrorCode();
3250                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3251
3252
3253                 // Check auditing for upload operation
3254                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3255
3256                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3257
3258                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3259                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
3260
3261                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
3262                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
3263 //              expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
3264                 expectedExternalAudit.setRESOURCE_NAME(componentInstance.getNormalizedName());
3265                 expectedExternalAudit.setRESOURCE_URL("/sdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts/" + artifactUUID);
3266                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3267
3268                 return restResponse;
3269         }
3270
3271
3272         // Delete artifact via external API + Check auditing for upload operation + Check response of external API
3273         protected RestResponse deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(Component resourceDetails, User sdncModifierDetails, String artifactUUID, Integer expectedResponseCode) throws Exception {
3274                 RestResponse restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfTheAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID);
3275
3276                 // Check response of external API
3277                 Integer responseCode = restResponse.getErrorCode();
3278                 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3279
3280
3281                 // Check auditing for upload operation
3282                 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3283
3284                 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3285
3286                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3287                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
3288
3289                 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
3290                 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
3291                 expectedExternalAudit.setRESOURCE_URL(expectedExternalAudit.getRESOURCE_URL()+ "/" + artifactUUID);
3292                 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3293
3294                 return restResponse;
3295         }
3296
3297
3298
3299         // download deployment via external api + check response code for success (200) + get artifactReqDetails and verify payload + verify audit
3300         protected RestResponse downloadResourceDeploymentArtifactExternalAPI(Component resourceDetails, User sdncModifierDetails, String artifactUUID, ComponentTypeEnum componentTypeEnum) throws Exception {
3301                 RestResponse restResponse;
3302
3303                 if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
3304                         restResponse = ArtifactRestUtils.getComponentInstanceDeploymentArtifactExternalAPI(resourceDetails.getUUID(), resourceDetails.getComponentInstances().get(0).getNormalizedName(), artifactUUID, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getComponentType().toString());
3305                 } else {
3306                         restResponse = ArtifactRestUtils.getResourceDeploymentArtifactExternalAPI(resourceDetails.getUUID(), artifactUUID, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getComponentType().toString());
3307                 }
3308
3309                 Integer responseCode = restResponse.getErrorCode();
3310                 Integer expectedCode = 404;
3311                 Assert.assertEquals(responseCode,expectedCode, "Response code is not correct.");
3312
3313
3314                 //TODO - including body - resourceDetails.getName()
3315 //                      // Verify audit
3316 //                      String auditAction = "DownloadArtifact";
3317 //
3318 //                      Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3319 //                      body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
3320 //                      body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
3321 //
3322 //                      ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = new ExpectedResourceAuditJavaObject();
3323 //                      expectedResourceAuditJavaObject.setAction(auditAction);
3324 //                      expectedResourceAuditJavaObject.setResourceType(resourceDetails.getComponentType().getValue());
3325 //                      expectedResourceAuditJavaObject.setStatus("200");
3326 //                      expectedResourceAuditJavaObject.setDesc("OK");
3327 //                      expectedResourceAuditJavaObject.setCONSUMER_ID("ci");
3328 //
3329 //                      if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
3330 //                              expectedResourceAuditJavaObject.setResourceName(resourceDetails.getComponentInstances().get(0).getName());
3331 //                              String resource_url = String.format("/sdc/v1/catalog/services/%s/resourceInstances/%s/artifacts/%s", resourceDetails.getUUID(), resourceDetails.getComponentInstances().get(0).getNormalizedName(), artifactDefinition.getArtifactUUID());
3332 //                              expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
3333 //
3334 //                              AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
3335 //                      } else {
3336 //                              expectedResourceAuditJavaObject.setResourceName(resourceDetails.getName());
3337 //                              String resource_url = String.format("/sdc/v1/catalog/services/%s/artifacts/%s", resourceDetails.getUUID(), artifactDefinition.getArtifactUUID());
3338 //                              expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
3339 //                      }
3340 //
3341 //                      AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
3342
3343                 return restResponse;
3344
3345         }
3346
3347
3348
3349
3350         public Component getComponentInTargetLifeCycleState(String componentType, UserRoleEnum creatorUser, LifeCycleStatesEnum targetLifeCycleState, ResourceTypeEnum resourceTypeEnum) throws Exception {
3351                 Component resourceDetails = null;
3352
3353                 if((componentType.toLowerCase().equals("vf")) || (componentType.toLowerCase().equals("resource"))){
3354                         if(resourceTypeEnum==null) {
3355                                 resourceTypeEnum = ResourceTypeEnum.VF;
3356                         }
3357                         Either<Resource, RestResponse> createdResource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(resourceTypeEnum, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, creatorUser, true);
3358                         resourceDetails = createdResource.left().value();
3359                         resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, creatorUser, targetLifeCycleState, true).getLeft();
3360                 } else {
3361                         Either<Service, RestResponse> createdResource = AtomicOperationUtils.createDefaultService(creatorUser, true);
3362                         resourceDetails = createdResource.left().value();
3363                         // Add artifact to service if asked for certifcationrequest - must be at least one artifact for the flow
3364                         if((LifeCycleStatesEnum.CERTIFICATIONREQUEST == targetLifeCycleState) || (LifeCycleStatesEnum.STARTCERTIFICATION == targetLifeCycleState)) {
3365                                                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.OTHER, resourceDetails, UserRoleEnum.DESIGNER, true, true).left().value();
3366                         }
3367                         resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, creatorUser, targetLifeCycleState, true).getLeft();
3368                 }
3369
3370                 return resourceDetails;
3371         }
3372
3373
3374
3375
3376
3377         protected String createUploadArtifactBodyJson() {
3378                 Map<String, Object> jsonBody = new HashMap<String, Object>();
3379                 jsonBody.put("artifactName", UPLOAD_ARTIFACT_NAME);
3380                 jsonBody.put("artifactDisplayName", "configure");
3381                 jsonBody.put("artifactType", "SHELL");
3382                 jsonBody.put("mandatory", "false");
3383                 jsonBody.put("description", "ff");
3384                 jsonBody.put("payloadData", UPLOAD_ARTIFACT_PAYLOAD);
3385                 jsonBody.put("artifactLabel", "configure");
3386                 return gson.toJson(jsonBody);
3387         }
3388
3389         protected ArtifactDefinition getArtifactDataFromJson(String content) {
3390                 JsonObject jsonElement = new JsonObject();
3391                 ArtifactDefinition resourceInfo = null;
3392
3393                 try {
3394                         Gson gson = new Gson();
3395                         jsonElement = gson.fromJson(content, jsonElement.getClass());
3396                         JsonElement artifactGroupValue = jsonElement.get(Constants.ARTIFACT_GROUP_TYPE_FIELD);
3397                         if (artifactGroupValue != null && !artifactGroupValue.isJsonNull()) {
3398                                 String groupValueUpper = artifactGroupValue.getAsString().toUpperCase();
3399                                 if (!ArtifactGroupTypeEnum.getAllTypes().contains(groupValueUpper)) {
3400                                         StringBuilder sb = new StringBuilder();
3401                                         for (String value : ArtifactGroupTypeEnum.getAllTypes()) {
3402                                                 sb.append(value).append(", ");
3403                                         }
3404                                         log.debug("artifactGroupType is {}. valid values are: {}", groupValueUpper, sb.toString());
3405                                         return null;
3406                                 } else {
3407                                         jsonElement.remove(Constants.ARTIFACT_GROUP_TYPE_FIELD);
3408                                         jsonElement.addProperty(Constants.ARTIFACT_GROUP_TYPE_FIELD, groupValueUpper);
3409                                 }
3410                         }
3411                         String payload = null;
3412                         JsonElement artifactPayload = jsonElement.get(Constants.ARTIFACT_PAYLOAD_DATA);
3413                         if (artifactPayload != null && !artifactPayload.isJsonNull()) {
3414                                 payload = artifactPayload.getAsString();
3415                         }
3416                         jsonElement.remove(Constants.ARTIFACT_PAYLOAD_DATA);
3417                         String json = gson.toJson(jsonElement);
3418                         ObjectMapper mapper = new ObjectMapper();
3419                         mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
3420                         mapper.configure(Feature.FAIL_ON_EMPTY_BEANS, false);
3421                         mapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL);
3422
3423                         resourceInfo = mapper.readValue(json, ArtifactDefinition.class);
3424                         resourceInfo.setPayloadData(payload);
3425
3426                 } catch (Exception e) {
3427                         BeEcompErrorManager.getInstance().processEcompError(EcompErrorName.BeArtifactInformationInvalidError, "Artifact Upload / Update");
3428                         BeEcompErrorManager.getInstance().logBeArtifactInformationInvalidError("Artifact Upload / Update");
3429                         log.debug("Failed to convert the content {} to object.", content.substring(0, Math.min(50, content.length())), e);
3430                 }
3431
3432                 return resourceInfo;
3433         }
3434
3435         protected HttpGet createGetRequest(String url) {
3436                 HttpGet httpGet = new HttpGet(url);
3437                 httpGet.addHeader(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
3438                 httpGet.addHeader(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
3439                 httpGet.addHeader(HttpHeaderEnum.USER_ID.getValue(), sdncUserDetails.getUserId());
3440                 return httpGet;
3441         }
3442
3443         protected String getArtifactUid(HttpResponse response) throws HttpResponseException, IOException, ParseException {
3444                 String responseString = new BasicResponseHandler().handleResponse(response);
3445                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3446                 String artifactId = (String) responseMap.get("uniqueId");
3447                 return artifactId;
3448         }
3449
3450         protected String getArtifactEsId(HttpResponse response) throws HttpResponseException, IOException, ParseException {
3451                 String responseString = new BasicResponseHandler().handleResponse(response);
3452                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3453                 String esId = (String) responseMap.get("EsId");
3454                 return esId;
3455         }
3456
3457         protected ArtifactDefinition addArtifactDataFromResponse(HttpResponse response, ArtifactDefinition artifact) throws HttpResponseException, IOException, ParseException {
3458                 //String responseString = new BasicResponseHandler().handleResponse(response);
3459                 HttpEntity entity = response.getEntity();
3460                 String responseString = EntityUtils.toString(entity);
3461                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3462                 artifact.setEsId((String)responseMap.get("esId"));
3463                 artifact.setUniqueId((String) responseMap.get("uniqueId"));
3464                 artifact.setArtifactGroupType(ArtifactGroupTypeEnum.findType((String) responseMap.get("artifactGroupType")));
3465                 artifact.setTimeout(((Long) responseMap.get("timeout")).intValue());
3466                 return artifact;
3467         }
3468
3469         protected String getLifecycleArtifactUid(CloseableHttpResponse response) throws HttpResponseException, IOException, ParseException {
3470                 String responseString = new BasicResponseHandler().handleResponse(response);
3471                 JSONObject responseMap = (JSONObject) jsonParser.parse(responseString);
3472                 responseMap = (JSONObject) responseMap.get("implementation");
3473                 String artifactId = (String) responseMap.get("uniqueId");
3474                 return artifactId;
3475         }
3476
3477         protected HttpDelete createDeleteArtifactRequest(String url) {
3478                 HttpDelete httpDelete = new HttpDelete(url);
3479                 httpDelete.addHeader(HttpHeaderEnum.USER_ID.getValue(), sdncUserDetails.getUserId());
3480                 httpDelete.addHeader(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
3481                 return httpDelete;
3482         }
3483
3484         protected HttpPost createPostAddArtifactRequeast(String jsonBody, String url, boolean addMd5Header) throws UnsupportedEncodingException {
3485                 HttpPost httppost = new HttpPost(url);
3486                 httppost.addHeader(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
3487                 httppost.addHeader(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
3488                 httppost.addHeader(HttpHeaderEnum.USER_ID.getValue(), sdncUserDetails.getUserId());
3489                 if (addMd5Header) {
3490                         httppost.addHeader(HttpHeaderEnum.Content_MD5.getValue(), GeneralUtility.calculateMD5ByString(jsonBody));
3491                 }
3492                 StringEntity input = new StringEntity(jsonBody);
3493                 input.setContentType("application/json");
3494                 httppost.setEntity(input);
3495                 log.debug("Executing request {}" , httppost.getRequestLine());
3496                 return httppost;
3497         }
3498
3499         protected String createLoadArtifactBody() {
3500                 Map<String, Object> json = new HashMap<String, Object>();
3501                 json.put("artifactName", "install_apache2.sh");
3502                 json.put("artifactType", "SHELL");
3503                 json.put("description", "ddd");
3504                 json.put("payloadData", "UEsDBAoAAAAIAAeLb0bDQz");
3505                 json.put("artifactLabel", "name123");
3506
3507                 String jsonStr = gson.toJson(json);
3508                 return jsonStr;
3509         }
3510
3511         protected void checkDeleteResponse(RestResponse response) {
3512                 BaseRestUtils.checkStatusCode(response, "delete request failed", false, 204, 404);
3513         }
3514
3515         protected ArtifactUiDownloadData getArtifactUiDownloadData(String artifactUiDownloadDataStr) throws Exception {
3516
3517                 ObjectMapper mapper = new ObjectMapper();
3518                 try {
3519                         ArtifactUiDownloadData artifactUiDownloadData = mapper.readValue(artifactUiDownloadDataStr, ArtifactUiDownloadData.class);
3520                         return artifactUiDownloadData;
3521                 } catch (Exception e) {
3522                         e.printStackTrace();
3523                 }
3524                 return null;
3525         }
3526
3527
3528 }