2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.ci.tests.execute.devCI;
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;
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;
95 import com.google.gson.Gson;
96 import com.google.gson.JsonElement;
97 import com.google.gson.JsonObject;
98 import com.relevantcodes.extentreports.LogStatus;
100 import fj.data.Either;
103 import static java.util.Arrays.asList;
105 public class CRUDExternalAPI extends ComponentBaseTest {
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";
111 protected Config config = Config.instance();
112 protected String contentTypeHeaderData = "application/json";
113 protected String acceptHeaderDate = "application/json";
117 protected Gson gson = new Gson();
118 protected JSONParser jsonParser = new JSONParser();
121 protected String serviceVersion;
122 protected ResourceReqDetails resourceDetails;
123 protected User sdncUserDetails;
124 protected ServiceReqDetails serviceDetails;
128 public void init() throws Exception{
129 AtomicOperationUtils.createDefaultConsumer(true);
134 public static TestName name = new TestName();
136 public CRUDExternalAPI() {
137 super(name, CRUDExternalAPI.class.getName());
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},
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},
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},
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},
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},
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},
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},
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},
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}
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);
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"},
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"},
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"}
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);
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"}
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);
353 @DataProvider(name="uploadArtifactOnServiceViaExternalAPIIncludingDistribution")
354 public static Object[][] dataProviderUploadArtifactOnServiceViaExternalAPIIncludingDistribution() {
355 return new Object[][] {
356 {LifeCycleStatesEnum.CHECKOUT, "YANG_XML"},
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);
365 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
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);
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;
383 ArtifactReqDetails artifactReqDetails = ElementFactory.getArtifactByType("ci", artifactType, true, false);
385 // create component/s & upload artifact via external api
386 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
388 component = getComponentWithResourceInstanceInTargetLifeCycleState(chosenLifeCycleState, resourceTypeEnum);
389 restResponse = uploadArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
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;
394 numberOfArtifact = (component.getComponentInstances().get(0).getDeploymentArtifacts() == null ? 0 : component.getComponentInstances().get(0).getDeploymentArtifacts().size()) + 1;
397 component = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, chosenLifeCycleState, resourceTypeEnum);
399 restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 200);
400 numberOfArtifact = component.getDeploymentArtifacts().size() + 1;
405 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
406 component = getNewerVersionOfComponent(component, chosenLifeCycleState);
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.");
412 // Download the uploaded artifact via external API
413 downloadResourceDeploymentArtifactExternalAPI(component, deploymentArtifacts.get(responseArtifact.getArtifactLabel()), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentTypeEnum);
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));
422 // Check response of external API
423 Integer responseCode = restResponse.getErrorCode();
424 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
427 // Check auditing for upload operation
428 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
430 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
432 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
433 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
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("/asdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts");
439 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
447 protected Component getComponentWithResourceInstanceInTargetLifeCycleState(LifeCycleStatesEnum lifeCycleStatesEnum, ResourceTypeEnum resourceTypeEnum) throws Exception {
449 if(resourceTypeEnum == ResourceTypeEnum.VF) {
450 component = getComponentInTargetLifeCycleState(ComponentTypeEnum.SERVICE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
452 Component resourceInstanceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.RESOURCE.getValue(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, null);
453 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceInstanceDetails, component, UserRoleEnum.DESIGNER, true).left().value();
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)) {
458 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.OTHER, component, UserRoleEnum.DESIGNER, true, true).left().value();
459 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, lifeCycleStatesEnum, true).getLeft();
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();
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);
478 // Check response of external API
479 Integer responseCode = restResponse.getErrorCode();
480 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
483 // Check auditing for upload operation
484 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
486 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
488 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
489 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
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);
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;
510 if((!lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKOUT)) && (!lifeCycleStatesEnum.equals(LifeCycleStatesEnum.STARTCERTIFICATION))) {
513 String resourceVersion = component.getVersion();
514 String resourceUniqueID = component.getUniqueId();
516 if(component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
517 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), String.format("%.1f", Double.parseDouble(component.getVersion()) + 0.1));
519 resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), String.format("%.1f", Double.parseDouble(component.getVersion()) + 0.1));
522 String resourceNewVersion = resourceDetails.getVersion();
523 String resourceNewUniqueID = resourceDetails.getUniqueId();
525 System.out.println(resourceNewVersion);
526 System.out.println("Service UUID: " + resourceDetails.getUUID());
527 System.out.println("Service UniqueID: " + resourceDetails.getUniqueId());
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.");
533 if(component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
534 resourceDetails = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
536 resourceDetails = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
539 return resourceDetails;
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;
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());
553 restResponse = ArtifactRestUtils.getResourceDeploymentArtifactExternalAPI(resourceDetails.getUUID(), artifactDefinition.getArtifactUUID(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getComponentType().toString());
556 Integer responseCode = restResponse.getErrorCode();
557 Integer expectedCode = 200;
558 Assert.assertEquals(responseCode,expectedCode, "Response code is not correct.");
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);
567 Assert.assertEquals(response, decodedPaypload, "Response artifact payload not correct.");
570 //TODO - including body - resourceDetails.getName()
572 // String auditAction = "DownloadArtifact";
574 // Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
575 // body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
576 // body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
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");
585 // if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
586 // expectedResourceAuditJavaObject.setResourceName(resourceDetails.getComponentInstances().get(0).getName());
587 // String resource_url = String.format("/asdc/v1/catalog/services/%s/resourceInstances/%s/artifacts/%s", resourceDetails.getUUID(), resourceDetails.getComponentInstances().get(0).getNormalizedName(), artifactDefinition.getArtifactUUID());
588 // expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
590 // AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
592 // expectedResourceAuditJavaObject.setResourceName(resourceDetails.getName());
593 // String resource_url = String.format("/asdc/v1/catalog/services/%s/artifacts/%s", resourceDetails.getUUID(), artifactDefinition.getArtifactUUID());
594 // expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
597 // AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
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());
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"},
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"},
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"}
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);
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},
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},
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},
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},
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},
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},
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},
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},
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}
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);
764 @DataProvider(name="uploadInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI")
765 public static Object[][] dataProviderUploadInvalidArtifactTypeExtensionLabelDescriptionCheckSumDuplicateLabelViaExternalAPI() {
766 return new Object[][] {
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"},
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"},
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"},
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"},
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"},
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"},
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"},
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"},
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"},
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"},
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;
882 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
883 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
885 resourceDetails = getComponentInTargetLifeCycleState(ComponentTypeEnum.SERVICE.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, null);
886 resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(chosenLifeCycleState, null);
887 componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
889 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.OTHER.toString(), true, false);
891 resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, chosenLifeCycleState, null);
895 switch (uploadArtifactTestType) {
896 case "uploadArtifactWithInvalidTypeToLong":
897 uploadArtifactWithInvalidTypeToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
899 case "uploadArtifactWithInvalidTypeEmpty":
900 uploadArtifactWithInvalidTypeEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
902 case "uploadArtifactWithInvalidCheckSum":
903 uploadArtifactWithInvalidCheckSum(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
905 case "uploadArtifactWithInvalidNameToLong":
906 uploadArtifactWithInvalidNameToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
908 case "uploadArtifactWithInvalidNameEmpty":
909 uploadArtifactWithInvalidNameEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
911 case "uploadArtifactWithInvalidLabelToLong":
912 uploadArtifactWithInvalidLabelToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
914 case "uploadArtifactWithInvalidLabelEmpty":
915 uploadArtifactWithInvalidLabelEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
917 case "uploadArtifactWithInvalidDescriptionToLong":
918 uploadArtifactWithInvalidDescriptionToLong(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
920 case "uploadArtifactWithInvalidDescriptionEmpty":
921 uploadArtifactWithInvalidDescriptionEmpty(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
923 case "uploadArtifactWithSameLabel":
925 uploadArtifactWithSameLabel(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
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());
937 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
938 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null);
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());
948 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
949 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null);
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);
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);
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();
979 artifactReqDetails.setArtifactName("");
980 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
981 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null);
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 {
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);
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 {
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);
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 {
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);
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 {
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);
1035 // Upload artifact with same label via external API
1036 protected void uploadArtifactWithSameLabel(Component resourceDetails, User sdncModifierDetails, ArtifactReqDetails artifactReqDetails,
1037 ComponentInstance componentResourceInstanceDetails) throws Exception {
1039 RestResponse restResponse = null;
1040 if(componentResourceInstanceDetails != null) {
1041 restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfComponentInstanceOnAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
1043 restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails);
1047 ArtifactDefinition artifactDefinition = getArtifactDataFromJson(restResponse.getResponse());
1048 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_EXIST.name());
1050 List<String> variables = asList(artifactDefinition.getArtifactDisplayName());
1051 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1052 artifactReqDetails, 400, componentResourceInstanceDetails, errorInfo, variables, null);
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;
1066 if(componentResourceInstanceDetails != null) {
1067 restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfComponentInstanceOnAsset(resourceDetails, sdncModifierDetails, artifactReqDetails, componentResourceInstanceDetails);
1069 restResponse = ArtifactRestUtils.externalAPIUploadArtifactOfTheAsset(resourceDetails, sdncModifierDetails, artifactReqDetails);
1073 // validate response code
1074 Integer responseCode = restResponse.getErrorCode();
1075 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
1077 // Check auditing for upload operation
1078 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
1080 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
1082 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
1083 // ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
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("/asdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts");
1096 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
1098 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getName());
1099 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
1100 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
1103 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
1105 return restResponse;
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;
1118 if(componentResourceInstanceDetails != null) {
1119 restResponse = ArtifactRestUtils.externalAPIUploadArtifactWithInvalidCheckSumOfComponentInstanceOnAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentResourceInstanceDetails);
1121 restResponse = ArtifactRestUtils.externalAPIUploadArtifactWithInvalidCheckSumOfTheAsset(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails);
1125 // validate response code
1126 Integer responseCode = restResponse.getErrorCode();
1127 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
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");
1134 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
1136 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPLOAD_BY_API;
1138 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
1139 // ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
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("/asdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts");
1152 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
1154 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
1156 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPLOAD_BY_API.getName(), body);
1158 return restResponse;
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},
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},
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},
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},
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},
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},
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;
1226 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
1227 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
1229 resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(lifeCycleStatesEnum, null);
1230 componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
1232 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.OTHER.toString(), true, false);
1234 resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, lifeCycleStatesEnum, null);
1237 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
1238 List<String> variables = asList();
1240 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(userRoleEnum),
1241 artifactReqDetails, 409, componentResourceInstanceDetails, errorInfo, variables, lifeCycleStatesEnum);
1243 if(lifeCycleStatesEnum.equals(LifeCycleStatesEnum.CHECKIN)) {
1252 @DataProvider(name="uploadArtifactOnAssetWhichNotExist")
1253 public static Object[][] dataProviderUploadArtifactOnAssetWhichNotExist() {
1254 return new Object[][] {
1255 {ComponentTypeEnum.SERVICE},
1256 {ComponentTypeEnum.RESOURCE},
1257 {ComponentTypeEnum.RESOURCE_INSTANCE},
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;
1271 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
1272 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
1274 resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(LifeCycleStatesEnum.CHECKIN, null);
1275 componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
1277 resourceDetails.setUUID("12345");
1278 componentResourceInstanceDetails.setNormalizedName("12345");
1280 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", "OTHER", true, false);
1282 resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, null);
1284 resourceDetails.setUUID("12345");
1287 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
1288 List<String> variables = asList("null");
1290 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1291 artifactReqDetails, 404, componentResourceInstanceDetails, errorInfo, variables, LifeCycleStatesEnum.CHECKIN);
1298 @DataProvider(name="uploadArtifactOnAssetWhichInInvalidStateForUploading")
1299 public static Object[][] dataProviderUploadArtifactOnAssetWhichInInvalidStateForUploading() {
1300 return new Object[][] {
1301 {ComponentTypeEnum.SERVICE},
1302 {ComponentTypeEnum.RESOURCE},
1303 {ComponentTypeEnum.RESOURCE_INSTANCE},
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;
1315 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
1316 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.DCAE_INVENTORY_DOC.toString(), true, false);
1318 resourceDetails = getComponentWithResourceInstanceInTargetLifeCycleState(LifeCycleStatesEnum.STARTCERTIFICATION, null);
1319 componentResourceInstanceDetails = resourceDetails.getComponentInstances().get(0);
1321 artifactReqDetails = ElementFactory.getArtifactByType("Abcd", ArtifactTypeEnum.OTHER.toString(), true, false);
1323 resourceDetails = getComponentInTargetLifeCycleState(componentTypeEnum.toString(), UserRoleEnum.DESIGNER, LifeCycleStatesEnum.STARTCERTIFICATION, null);
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());
1330 uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1331 artifactReqDetails, 403, componentResourceInstanceDetails, errorInfo, variables, LifeCycleStatesEnum.STARTCERTIFICATION);
1337 ////////////////////////////////////////////////////////////////////////////////////
1338 ////////////////////////////////////////////////////////////////////////////////////
1339 ////////////////////////////////////////////////////////////////////////////////////
1340 // Update External API //
1341 ////////////////////////////////////////////////////////////////////////////////////
1342 ////////////////////////////////////////////////////////////////////////////////////
1343 ////////////////////////////////////////////////////////////////////////////////////
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"}
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);
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);
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"},
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"},
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"}
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);
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);
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},
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},
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},
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},
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},
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},
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},
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},
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}
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);
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);
1560 @DataProvider(name="updateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI")
1561 public static Object[][] dataProviderUpdateArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI() {
1562 return new Object[][] {
1563 {ResourceTypeEnum.VFC},
1564 {ResourceTypeEnum.VL},
1565 {ResourceTypeEnum.CP}
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));
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());
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();
1593 List<String> variables = asList(artifactUUID);
1594 updateArtifactOnAssetViaExternalAPI(component, ComponentTypeEnum.RESOURCE_INSTANCE, LifeCycleStatesEnum.CHECKOUT, "SNMP_TRAP", errorInfo, variables, UserRoleEnum.DESIGNER, 404);
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},
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},
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}
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);
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);
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},
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},
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},
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},
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},
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},
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},
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},
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}
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);
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);
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"},
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"},
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"},
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"},
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"},
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"},
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"},
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);
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},
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);
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();
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);
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);
1862 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1863 404, null, artifactReqDetails, invalidArtifactUUID, errorInfo, variables, null);
1867 // Invalid componentUUID
1868 // errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
1869 // variables = asList("null");
1871 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
1872 component.getComponentInstances().get(0).setNormalizedName("invalidNormalizedName");
1874 errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER.name());
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);
1880 component.setUUID("invalidComponentUUID");
1882 errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name());
1883 variables = asList("null");
1885 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
1886 404, null, artifactReqDetails, artifactUUID, errorInfo, variables, LifeCycleStatesEnum.CHECKIN);
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"},
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);
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"},
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"},
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"},
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"},
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"},
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"},
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"},
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;
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);
2008 artifactType = ArtifactTypeEnum.OTHER.toString();
2009 component = uploadArtifactOnAssetViaExternalAPI(componentTypeEnum, LifeCycleStatesEnum.CHECKIN, artifactType, null);
2012 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
2014 switch (uploadArtifactTestType) {
2015 case "updateArtifactWithInvalidCheckSum":
2016 updateArtifactWithInvalidCheckSum(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2018 case "updateArtifactWithInvalidNameToLong":
2019 updateArtifactWithInvalidNameToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2021 case "updateArtifactWithInvalidNameEmpty":
2022 updateArtifactWithInvalidNameEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2024 case "updateArtifactWithInvalidLabelToLong":
2025 updateArtifactWithInvalidLabelToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2027 case "updateArtifactWithInvalidLabelEmpty":
2028 updateArtifactWithInvalidLabelEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2030 case "updateArtifactWithInvalidDescriptionToLong":
2031 updateArtifactWithInvalidDescriptionToLong(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
2033 case "updateArtifactWithInvalidDescriptionEmpty":
2035 updateArtifactWithInvalidDescriptionEmpty(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactType, componentInstance);
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);
2047 //// artifactReqDetails.setArtifactType("");
2048 //// restResponse = uploadArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, 400, componentResourceInstanceDetails);
2049 //// artifactReqDetails.setArtifactType(artifactType);
2050 ///////////////////////////////////////////////////////////////////////////////
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);
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 {
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();
2074 deploymentArtifacts = component.getDeploymentArtifacts();
2077 for (String key : deploymentArtifacts.keySet()) {
2078 if (key.startsWith("ci")) {
2079 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2084 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.EXCEEDS_LIMIT.name());
2085 List<String> variables = asList("artifact name", "255");
2086 artifactReqDetails.setArtifactName("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2088 if(componentInstance != null) {
2089 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2090 400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null);
2092 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2093 400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null);
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 {
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();
2109 deploymentArtifacts = component.getDeploymentArtifacts();
2112 for (String key : deploymentArtifacts.keySet()) {
2113 if (key.startsWith("ci")) {
2114 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2119 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_ARTIFACT_NAME.name());
2120 List<String> variables = asList();
2121 artifactReqDetails.setArtifactName("");
2123 if(componentInstance != null) {
2124 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2125 400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null);
2127 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2128 400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null);
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 {
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();
2144 deploymentArtifacts = component.getDeploymentArtifacts();
2147 for (String key : deploymentArtifacts.keySet()) {
2148 if (key.startsWith("ci")) {
2149 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2154 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2155 List<String> variables = asList();
2156 artifactReqDetails.setArtifactLabel("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2158 if(componentInstance != null) {
2159 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2160 400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null);
2162 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2163 400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null);
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 {
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();
2179 deploymentArtifacts = component.getDeploymentArtifacts();
2182 for (String key : deploymentArtifacts.keySet()) {
2183 if (key.startsWith("ci")) {
2184 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2189 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
2190 List<String> variables = asList("artifact label");
2191 artifactReqDetails.setArtifactLabel("");
2193 if(componentInstance != null) {
2194 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2195 400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null);
2197 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2198 400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null);
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 {
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();
2214 deploymentArtifacts = component.getDeploymentArtifacts();
2217 for (String key : deploymentArtifacts.keySet()) {
2218 if (key.startsWith("ci")) {
2219 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2224 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2225 List<String> variables = asList();
2226 artifactReqDetails.setDescription("invalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeinvalGGfdsiofhdsouhfoidshfoidshoifhsdoifhdsouihfdsofhiufdsghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidTypeghiufghodhfioudsgafodsgaiofudsghifudsiugfhiufawsouipfhgawseiupfsadiughdfsoiuhgfaighfpasdghfdsaqgfdsgdfgidType");
2228 if(componentInstance != null) {
2229 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2230 400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null);
2232 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2233 400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null);
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 {
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();
2249 deploymentArtifacts = component.getDeploymentArtifacts();
2252 for (String key : deploymentArtifacts.keySet()) {
2253 if (key.startsWith("ci")) {
2254 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2260 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.ARTIFACT_LOGICAL_NAME_CANNOT_BE_CHANGED.name());
2261 List<String> variables = asList("artifact description");
2262 artifactReqDetails.setDescription("");
2264 if(componentInstance != null) {
2265 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2266 400, component.getComponentInstances().get(0), artifactReqDetails, artifactUUID, errorInfo, variables, null);
2268 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
2269 400, null, artifactReqDetails, artifactUUID, errorInfo, variables, null);
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;
2281 // get updated artifact data
2282 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
2283 componentVersionBeforeUpdate = component.getVersion();
2285 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2286 ArtifactReqDetails artifactReqDetails = getUpdatedArtifact(deploymentArtifacts, artifactType);
2288 String artifactName = artifactReqDetails.getArtifactLabel();
2289 String artifactUUID = deploymentArtifacts.get(artifactName).getArtifactUUID();
2290 String artifactVersionBeforeUpdate = deploymentArtifacts.get(artifactName).getArtifactVersion();
2291 int numberOfArtifact = deploymentArtifacts.size();
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);
2298 updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2299 expectedResponseCode, null, artifactReqDetails, artifactUUID, errorInfo, variables, chosenLifeCycleState);
2302 if(component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
2303 component = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
2305 component = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, component.getName(), component.getVersion());
2308 // Get list of deployment artifact + download them via external API
2309 if(ComponentTypeEnum.RESOURCE_INSTANCE == componentTypeEnum) {
2310 deploymentArtifacts = component.getComponentInstances().get(0).getDeploymentArtifacts();
2312 deploymentArtifacts = component.getDeploymentArtifacts();
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.");
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;
2326 if(componentInstance != null) {
2327 restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfComponentInstanceOnAsset(resourceDetails, sdncModifierDetails, artifactReqDetails, componentInstance, artifactUUID);
2329 restResponse = ArtifactRestUtils.externalAPIUpdateArtifactOfTheAsset(resourceDetails, sdncModifierDetails, artifactReqDetails, artifactUUID);
2333 // validate response code
2334 Integer responseCode = restResponse.getErrorCode();
2335 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2338 // Check auditing for upload operation
2339 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2341 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2343 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
2344 // ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
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("/asdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts/" + artifactUUID);
2358 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
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());
2365 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
2369 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2371 return restResponse;
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")) {
2389 return downloadResourceDeploymentArtifactExternalAPI(component, component.getDeploymentArtifacts().get(artifactName), sdncModifierDetails, artifactReqDetails, componentTypeEnum);
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();
2403 deploymentArtifacts = component.getDeploymentArtifacts();
2405 return deploymentArtifacts;
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);
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());
2421 return artifactReqDetails;
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;
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);
2441 for (String key : deploymentArtifacts.keySet()) {
2442 if (key.startsWith("ci")) {
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());
2453 component = AtomicOperationUtils.changeComponentState(component, UserRoleEnum.DESIGNER, chosenLifeCycleState, true).getLeft();
2454 componentVersionBeforeUpdate = component.getVersion();
2455 deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2456 numberOfArtifact = deploymentArtifacts.size();
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;
2464 restResponse = updateArtifactOfRIIncludingValiditionOfAuditAndResponseCode(component, component.getComponentInstances().get(0), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID, 200);
2467 restResponse = updateArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, artifactUUID, 200);
2472 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2473 component = getNewerVersionOfComponent(component, chosenLifeCycleState);
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.");
2480 if(chosenLifeCycleState == LifeCycleStatesEnum.CHECKOUT) {
2481 Assert.assertEquals(componentVersionBeforeUpdate, component.getVersion(), "Expected that check-out component will not change version number.");
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.");
2486 // Download the uploaded artifact via external API
2487 downloadResourceDeploymentArtifactExternalAPI(component, deploymentArtifacts.get(responseArtifact.getArtifactLabel()), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactReqDetails, componentTypeEnum);
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);
2497 // Check response of external API
2498 Integer responseCode = restResponse.getErrorCode();
2499 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2502 // Check auditing for upload operation
2503 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2505 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2507 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2508 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
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("/asdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts/" + artifactUUID);
2515 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_UPDATE_BY_API.getName(), body);
2517 return restResponse;
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);
2525 // Check response of external API
2526 Integer responseCode = restResponse.getErrorCode();
2527 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
2530 // Check auditing for upload operation
2531 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
2533 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_UPDATE_BY_API;
2535 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
2536 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
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);
2543 return restResponse;
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"}
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);
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"},
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"},
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"},
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);
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},
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},
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},
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},
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},
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},
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},
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},
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}
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);
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},
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},
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}
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);
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},
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},
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},
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},
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},
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},
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},
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},
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}
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);
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"},
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"},
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"},
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"},
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"},
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"},
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"},
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);
2953 String artifactUUID = null;
2954 for (String key : deploymentArtifacts.keySet()) {
2955 if (key.startsWith("ci")) {
2956 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
2961 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
2962 List<String> variables = asList();
2964 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
2965 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2966 409, component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, lifeCycleStatesEnum);
2968 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(userRoleEnum),
2969 409, null, artifactUUID, errorInfo, variables, lifeCycleStatesEnum);
2973 // downloadResourceDeploymentArtifactExternalAPI(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, componentTypeEnum);
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},
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);
2994 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
2996 String artifactUUID = null;
2997 for (String key : deploymentArtifacts.keySet()) {
2998 if (key.startsWith("ci")) {
2999 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
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);
3009 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
3010 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3011 404, component.getComponentInstances().get(0), invalidArtifactUUID, errorInfo, variables, null);
3013 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3014 404, null, invalidArtifactUUID, errorInfo, variables, null);
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);
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);
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"},
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();
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();
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());
3070 if(componentTypeEnum.equals(ComponentTypeEnum.RESOURCE_INSTANCE)) {
3071 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3072 403, component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, null);
3074 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3075 403, null, artifactUUID, errorInfo, variables, null);
3082 @DataProvider(name="deleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI")
3083 public static Object[][] dataProviderDeleteArtifactOfVfcVlCpForVfciVliCpiViaExternalAPI() {
3084 return new Object[][] {
3085 {ResourceTypeEnum.VFC},
3086 {ResourceTypeEnum.VL},
3087 {ResourceTypeEnum.CP}
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));
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());
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();
3115 List<String> variables = asList(artifactUUID);
3116 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
3117 404, component.getComponentInstances().get(0), artifactUUID, errorInfo, variables, null);
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;
3124 if(componentInstance != null) {
3125 restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfComponentInstanceOnAsset(resourceDetails, sdncModifierDetails, componentInstance, artifactUUID);
3127 restResponse = ArtifactRestUtils.externalAPIDeleteArtifactOfTheAsset(resourceDetails, sdncModifierDetails, artifactUUID);
3131 // validate response code
3132 Integer responseCode = restResponse.getErrorCode();
3133 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3135 // Check auditing for upload operation
3136 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3138 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3140 AssetTypeEnum assetTypeEnum = AssetTypeEnum.valueOf((resourceDetails.getComponentType().getValue() + "s").toUpperCase());
3141 // ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalArtifactAuditSuccess(assetTypeEnum, action, responseArtifact, resourceDetails);
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("/asdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + resourceDetails.getComponentInstances().get(0).getNormalizedName() + "/artifacts/" + artifactUUID);
3155 expectedExternalAudit.setRESOURCE_NAME(resourceDetails.getComponentInstances().get(0).getNormalizedName());
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());
3164 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
3168 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3170 return restResponse;
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();
3181 // get updated artifact data
3182 String artifactUUID = null;
3183 Map<String, ArtifactDefinition> deploymentArtifacts = getDeploymentArtifactsOfAsset(component, componentTypeEnum);
3185 for (String key : deploymentArtifacts.keySet()) {
3186 if (key.startsWith("ci")) {
3188 artifactUUID = deploymentArtifacts.get(key).getArtifactUUID();
3194 String componentVersionBeforeDelete = component.getVersion();
3195 int numberOfArtifact = deploymentArtifacts.size();
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);
3202 deleteArtifactOfAssetIncludingValiditionOfAuditAndResponseCode(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, 200);
3205 component = getNewerVersionOfComponent(component, chosenLifeCycleState);
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.");
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.");
3215 Assert.assertEquals(numberOfArtifact - 1, deploymentArtifacts.keySet().size(), "Expected that number of deployment artifact will decrease by one.");
3219 if(chosenLifeCycleState == LifeCycleStatesEnum.CHECKOUT) {
3220 Assert.assertEquals(componentVersionBeforeDelete, component.getVersion(), "Expected that check-out component will not change version number.");
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.");
3225 downloadResourceDeploymentArtifactExternalAPI(component, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), artifactUUID, componentTypeEnum);
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);
3234 // Check response of external API
3235 Integer responseCode = restResponse.getErrorCode();
3236 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3239 // Check auditing for upload operation
3240 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3242 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3244 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3245 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, componentInstance.getNormalizedName());
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("/asdc/v1/catalog/" + assetTypeEnum.getValue() + "/" + resourceDetails.getUUID() + "/resourceInstances/" + componentInstance.getNormalizedName() + "/artifacts/" + artifactUUID);
3252 AuditValidationUtils.validateExternalAudit(expectedExternalAudit, AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName(), body);
3254 return restResponse;
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);
3262 // Check response of external API
3263 Integer responseCode = restResponse.getErrorCode();
3264 Assert.assertEquals(responseCode, expectedResponseCode, "Response code is not correct.");
3267 // Check auditing for upload operation
3268 ArtifactDefinition responseArtifact = getArtifactDataFromJson(restResponse.getResponse());
3270 AuditingActionEnum action = AuditingActionEnum.ARTIFACT_DELETE_BY_API;
3272 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3273 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
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);
3280 return restResponse;
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;
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());
3292 restResponse = ArtifactRestUtils.getResourceDeploymentArtifactExternalAPI(resourceDetails.getUUID(), artifactUUID, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getComponentType().toString());
3295 Integer responseCode = restResponse.getErrorCode();
3296 Integer expectedCode = 404;
3297 Assert.assertEquals(responseCode,expectedCode, "Response code is not correct.");
3300 //TODO - including body - resourceDetails.getName()
3302 // String auditAction = "DownloadArtifact";
3304 // Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
3305 // body.put(AuditingFieldsKeysEnum.AUDIT_STATUS, responseCode.toString());
3306 // body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceDetails.getName());
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");
3315 // if(componentTypeEnum == ComponentTypeEnum.RESOURCE_INSTANCE) {
3316 // expectedResourceAuditJavaObject.setResourceName(resourceDetails.getComponentInstances().get(0).getName());
3317 // String resource_url = String.format("/asdc/v1/catalog/services/%s/resourceInstances/%s/artifacts/%s", resourceDetails.getUUID(), resourceDetails.getComponentInstances().get(0).getNormalizedName(), artifactDefinition.getArtifactUUID());
3318 // expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
3320 // AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
3322 // expectedResourceAuditJavaObject.setResourceName(resourceDetails.getName());
3323 // String resource_url = String.format("/asdc/v1/catalog/services/%s/artifacts/%s", resourceDetails.getUUID(), artifactDefinition.getArtifactUUID());
3324 // expectedResourceAuditJavaObject.setRESOURCE_URL(resource_url);
3327 // AuditValidationUtils.validateAuditDownloadExternalAPI(expectedResourceAuditJavaObject, auditAction, null, false);
3329 return restResponse;
3336 public Component getComponentInTargetLifeCycleState(String componentType, UserRoleEnum creatorUser, LifeCycleStatesEnum targetLifeCycleState, ResourceTypeEnum resourceTypeEnum) throws Exception {
3337 Component resourceDetails = null;
3339 if((componentType.toLowerCase().equals("vf")) || (componentType.toLowerCase().equals("resource"))){
3340 if(resourceTypeEnum==null) {
3341 resourceTypeEnum = ResourceTypeEnum.VF;
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();
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();
3353 resourceDetails = AtomicOperationUtils.changeComponentState(resourceDetails, creatorUser, targetLifeCycleState, true).getLeft();
3356 return resourceDetails;
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);
3375 protected ArtifactDefinition getArtifactDataFromJson(String content) {
3377 JsonObject jsonElement = new JsonObject();
3378 ArtifactDefinition resourceInfo = null;
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(", ");
3391 log.debug("artifactGroupType is {}. valid values are: {}", groupValueUpper, sb.toString());
3394 jsonElement.remove(Constants.ARTIFACT_GROUP_TYPE_FIELD);
3395 jsonElement.addProperty(Constants.ARTIFACT_GROUP_TYPE_FIELD, groupValueUpper);
3398 String payload = null;
3399 JsonElement artifactPayload = jsonElement.get(Constants.ARTIFACT_PAYLOAD_DATA);
3400 if (artifactPayload != null && !artifactPayload.isJsonNull()) {
3401 payload = artifactPayload.getAsString();
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);
3410 resourceInfo = mapper.readValue(json, ArtifactDefinition.class);
3411 resourceInfo.setPayloadData(payload);
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);
3418 return resourceInfo;
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());
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");
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");
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());
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");
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);
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());
3477 httppost.addHeader(HttpHeaderEnum.Content_MD5.getValue(), GeneralUtility.calculateMD5ByString(jsonBody));
3479 StringEntity input = new StringEntity(jsonBody);
3480 input.setContentType("application/json");
3481 httppost.setEntity(input);
3482 log.debug("Executing request {}" , httppost.getRequestLine());
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");
3494 String jsonStr = gson.toJson(json);
3498 protected void checkDeleteResponse(RestResponse response) {
3499 BaseRestUtils.checkStatusCode(response, "delete request failed", false, 204, 404);
3502 protected ArtifactUiDownloadData getArtifactUiDownloadData(String artifactUiDownloadDataStr) throws Exception {
3504 ObjectMapper mapper = new ObjectMapper();
3506 ArtifactUiDownloadData artifactUiDownloadData = mapper.readValue(artifactUiDownloadDataStr, ArtifactUiDownloadData.class);
3507 return artifactUiDownloadData;
3508 } catch (Exception e) {
3509 e.printStackTrace();