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