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