test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/externalapi/DownloadArtifactsTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.externalapi;
  22
  23 import com.google.gson.Gson;
  24 import org.apache.commons.codec.binary.Base64;
  25 import org.junit.Rule;
  26 import org.junit.rules.TestName;
  27 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  28 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  29 import org.openecomp.sdc.be.model.*;
  30 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  31 import org.openecomp.sdc.ci.tests.api.Urls;
  32 import org.openecomp.sdc.ci.tests.datatypes.*;
  33 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
  34 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  35 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  36 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  37 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  38 import org.openecomp.sdc.ci.tests.utils.rest.*;
  39 import org.testng.Assert;
  40 import org.testng.annotations.BeforeMethod;
  41 import org.testng.annotations.Test;
  42
  43 import java.io.IOException;
  44 import java.nio.file.Files;
  45 import java.nio.file.Path;
  46 import java.nio.file.Paths;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50
  51 import static org.testng.AssertJUnit.*;
  52
  53 public class DownloadArtifactsTest extends ComponentBaseTest {
  54         @Rule
  55         public static TestName name = new TestName();
  56
  57         Gson gson = new Gson();
  58
  59         public DownloadArtifactsTest() {
  60                 super(name, DownloadArtifactsTest.class.getName());
  61         }
  62
  63         private User sdncDesignerDetails;
  64         private User sdncAdminDetails;
  65         private ImportReqDetails resourceDetailsVF_01;
  66         private ResourceReqDetails resourceDetailsVF_02;
  67         private ResourceReqDetails resourceDetailsVF_03;
  68         private ResourceReqDetails resourceDetailsCP_01;
  69         private ServiceReqDetails serviceDetails_01;
  70         private ServiceReqDetails serviceDetails_02;
  71         public static String rootPath = System.getProperty("user.dir");
  72
  73         @BeforeMethod(alwaysRun = true)
  74         public void before() throws Exception {
  75                 init();
  76                 createComponents();
  77         }
  78
  79         private void createComponents() throws Exception {
  80                 createAtomicResource(resourceDetailsCP_01);
  81                 importVfWithArtifacts(resourceDetailsVF_01);
  82                 createVF(resourceDetailsVF_03);
  83                 createVF(resourceDetailsVF_02);
  84                 createService(serviceDetails_01);
  85         }
  86
  87         public void init() {
  88                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  89                 sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  90                 resourceDetailsVF_01 = ElementFactory.getDefaultImportResourceByType("VF100", NormativeTypesEnum.ROOT,
  91                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(),
  92                                 ResourceTypeEnum.VF.toString());
  93                 resourceDetailsVF_02 = ElementFactory.getDefaultResourceByType("VF200", NormativeTypesEnum.ROOT,
  94                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(),
  95                                 ResourceTypeEnum.VF.toString());
  96                 resourceDetailsVF_03 = ElementFactory.getDefaultResourceByType("VF300", NormativeTypesEnum.ROOT,
  97                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(),
  98                                 ResourceTypeEnum.VF.toString());
  99                 resourceDetailsCP_01 = ElementFactory.getDefaultResourceByType("CP100", NormativeTypesEnum.PORT,
 100                                 ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, sdncDesignerDetails.getUserId(),
 101                                 ResourceTypeEnum.CP.toString());
 102                 serviceDetails_01 = ElementFactory.getDefaultService("newtestservice1", ServiceCategoriesEnum.MOBILITY,
 103                                 sdncDesignerDetails.getUserId(),
 104                                 ServiceInstantiationType.A_LA_CARTE.getValue());
 105                 serviceDetails_02 = ElementFactory.getDefaultService("newtestservice2", ServiceCategoriesEnum.MOBILITY,
 106                                 sdncDesignerDetails.getUserId(),
 107                                 ServiceInstantiationType.A_LA_CARTE.getValue());
 108         }
 109
 110         @Test
 111         public void downloadResourceInstanceArtifactsFromServiceTest() throws Exception {
 112                 Service service = createServiceWithRIsWithArtifacts();
 113                 Map<String, ArtifactDefinition> deploymentArtifacts;
 114                 List<ComponentInstance> resourceInstances = service.getComponentInstances();
 115                 for (ComponentInstance ri : resourceInstances) {
 116                         deploymentArtifacts = ri.getDeploymentArtifacts();
 117                         for (ArtifactDefinition artifact : deploymentArtifacts.values()) {
 118                                 assertNotNull(downloadResourceInstanceArtifact(service, ri, artifact));
 119                         }
 120                 }
 121         }
 122
 123         @Test
 124         public void downloadServiceArtifactsTest() throws Exception {
 125                 Service service = createServiceWithArtifacts();
 126                 Map<String, ArtifactDefinition> deploymentArtifacts = service.getDeploymentArtifacts();
 127                 for (ArtifactDefinition artifact : deploymentArtifacts.values()) {
 128                         assertNotNull(downloadServiceArtifact(service, artifact));
 129                 }
 130
 131         }
 132
 133         private Service createServiceWithArtifacts() throws Exception {
 134
 135                 ArtifactReqDetails otherArtifactDetails = ElementFactory
 136                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.OTHER.getType());
 137
 138                 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(
 139                                 otherArtifactDetails, sdncDesignerDetails, serviceDetails_01.getUniqueId());
 140                 assertTrue(
 141                                 "response code is not BaseRestUtils.STATUS_CODE_SUCCESS, returned :"
 142                                                 + addInformationalArtifactToService.getErrorCode(),
 143                                 addInformationalArtifactToService.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
 144
 145                 ArtifactReqDetails yangXmlArtifactDetails = ElementFactory
 146                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.YANG_XML.getType());
 147
 148                 addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(yangXmlArtifactDetails,
 149                                 sdncDesignerDetails, serviceDetails_01.getUniqueId());
 150                 assertTrue(
 151                                 "response code is not BaseRestUtils.STATUS_CODE_SUCCESS, returned :"
 152                                                 + addInformationalArtifactToService.getErrorCode(),
 153                                 addInformationalArtifactToService.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
 154                 RestResponse createServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 155                 return ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse());
 156         }
 157
 158         private RestResponse downloadResourceInstanceArtifact(Service service, ComponentInstance ri,
 159                         ArtifactDefinition artifact) throws Exception {
 160                 String url = String.format(Urls.GET_DOWNLOAD_SERVICE_RI_ARTIFACT, "localhost", "8080", service.getUUID(),
 161                                 ri.getUniqueId(), artifact.getArtifactUUID());
 162                 String userId = sdncDesignerDetails.getUserId();
 163                 Map<String, String> headersMap = new HashMap<String, String>();
 164                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), "application/json");
 165                 headersMap.put(HttpHeaderEnum.CACHE_CONTROL.getValue(), "no-cache");
 166                 headersMap.put(HttpHeaderEnum.AUTHORIZATION.getValue(), "Basic dGVzdDoxMjM0NTY=");
 167                 headersMap.put("X-ECOMP-InstanceID", "test");
 168                 if (userId != null) {
 169                         headersMap.put(HttpHeaderEnum.USER_ID.getValue(), userId);
 170                 }
 171                 sendAuthorizationRequest();
 172                 HttpRequest http = new HttpRequest();
 173                 RestResponse response = http.httpSendGet(url, headersMap);
 174                 if (response.getErrorCode() != 200 && response.getResponse().getBytes() == null
 175                                 && response.getResponse().getBytes().length == 0) {
 176                         return null;
 177                 }
 178                 return response;
 179         }
 180
 181         private RestResponse downloadServiceArtifact(Service service, ArtifactDefinition artifact) throws Exception {
 182                 String url = String.format(Urls.GET_DOWNLOAD_SERVICE_ARTIFACT, "localhost", "8080", service.getUUID(),
 183                                 artifact.getArtifactUUID());
 184                 String userId = sdncDesignerDetails.getUserId();
 185                 Map<String, String> headersMap = new HashMap<String, String>();
 186                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), "application/json");
 187                 headersMap.put(HttpHeaderEnum.CACHE_CONTROL.getValue(), "no-cache");
 188                 headersMap.put(HttpHeaderEnum.AUTHORIZATION.getValue(), "Basic dGVzdDoxMjM0NTY=");
 189                 headersMap.put("X-ECOMP-InstanceID", "test");
 190                 if (userId != null) {
 191                         headersMap.put(HttpHeaderEnum.USER_ID.getValue(), userId);
 192                 }
 193                 sendAuthorizationRequest();
 194                 HttpRequest http = new HttpRequest();
 195                 RestResponse response = http.httpSendGet(url, headersMap);
 196                 if (response.getErrorCode() != 200 && response.getResponse().getBytes() == null
 197                                 && response.getResponse().getBytes().length == 0) {
 198                         return null;
 199                 }
 200                 return response;
 201
 202         }
 203
 204         private RestResponse sendAuthorizationRequest() throws IOException {
 205                 String url = String.format(Urls.POST_AUTHORIZATION, "localhost", "8080");
 206                 String userId = sdncAdminDetails.getUserId();
 207                 Map<String, String> headersMap = new HashMap<String, String>();
 208                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), "application/json");
 209                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), "application/json");
 210                 headersMap.put(HttpHeaderEnum.CACHE_CONTROL.getValue(), "no-cache");
 211                 if (userId != null) {
 212                         headersMap.put(HttpHeaderEnum.USER_ID.getValue(), userId);
 213                 }
 214
 215                 HttpRequest http = new HttpRequest();
 216                 RestResponse response = http.httpSendPost(url,
 217                                 "{\"consumerName\":\"test\",\"consumerPassword\":\"0a0dc557c3bf594b1a48030e3e99227580168b21f44e285c69740b8d5b13e33b\",\"consumerSalt\":\"2a1f887d607d4515d4066fe0f5452a50\"}",
 218                                 headersMap);
 219                 if (response.getErrorCode() != 201) {
 220                         return null;
 221                 }
 222                 return response;
 223         }
 224
 225         private Service createServiceWithRIsWithArtifacts() throws Exception {
 226                 serviceDetails_02.setUniqueId(serviceDetails_01.getUniqueId());
 227                 createTreeCheckedinVFInstances();
 228                 LifecycleRestUtils.changeResourceState(resourceDetailsCP_01, sdncDesignerDetails, "0.1",
 229                                 LifeCycleStatesEnum.CHECKIN);
 230                 createVFInstanceAndAtomicResourceInstanceWithoutCheckin(resourceDetailsVF_01, resourceDetailsCP_01,
 231                                 sdncDesignerDetails);
 232                 RestResponse updateServiceResp = ServiceRestUtils.updateService(serviceDetails_02, sdncDesignerDetails);
 233                 ServiceRestUtils.checkSuccess(updateServiceResp);
 234                 getComponentAndValidateRIs(serviceDetails_01, 5, 0);
 235
 236                 return ResponseParser.convertServiceResponseToJavaObject(updateServiceResp.getResponse());
 237         }
 238
 239         private void createTreeCheckedinVFInstances() throws Exception {
 240                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 241                                 sdncDesignerDetails);
 242                 ResourceRestUtils.checkCreateResponse(createFirstVFInstResp);
 243                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
 244                                 sdncDesignerDetails);
 245                 ResourceRestUtils.checkCreateResponse(createSecondVFInstResp);
 246                 RestResponse createThirdVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_03,
 247                                 sdncDesignerDetails);
 248                 ResourceRestUtils.checkCreateResponse(createThirdVFInstResp);
 249         }
 250
 251         private Component getComponentAndValidateRIs(ComponentReqDetails componentDetails, int numberOfRIs,
 252                         int numberOfRelations) throws IOException, Exception {
 253
 254                 RestResponse getResponse = null;
 255                 Component component = null;
 256                 if (componentDetails instanceof ResourceReqDetails) {
 257                         getResponse = ResourceRestUtils.getResource(sdncAdminDetails, componentDetails.getUniqueId());
 258                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Resource.class);
 259                 } else if (componentDetails instanceof ServiceReqDetails) {
 260                         getResponse = ServiceRestUtils.getService((ServiceReqDetails) componentDetails, sdncAdminDetails);
 261                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Service.class);
 262                 } else if (componentDetails instanceof ProductReqDetails) {
 263                         getResponse = ProductRestUtils.getProduct(componentDetails.getUniqueId(), sdncAdminDetails.getUserId());
 264                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Product.class);
 265                 } else {
 266                         Assert.fail("Unsupported type of componentDetails - " + componentDetails.getClass().getSimpleName());
 267                 }
 268                 ResourceRestUtils.checkSuccess(getResponse);
 269                 int numberOfActualRIs = component.getComponentInstances() != null ? component.getComponentInstances().size()
 270                                 : 0;
 271                 int numberOfActualRelations = component.getComponentInstancesRelations() != null
 272                                 ? component.getComponentInstancesRelations().size() : 0;
 273                 assertEquals("Check number of RIs meet the expected number", numberOfRIs, numberOfActualRIs);
 274                 assertEquals("Check number of RI relations meet the expected number", numberOfRelations,
 275                                 numberOfActualRelations);
 276
 277                 return component;
 278         }
 279
 280         private void createVFInstanceAndAtomicResourceInstanceWithoutCheckin(ResourceReqDetails vf,
 281                         ResourceReqDetails atomicResource, User user) throws Exception {
 282                 RestResponse createVFInstance = createVFInstance(serviceDetails_01, vf, user);
 283                 ResourceRestUtils.checkCreateResponse(createVFInstance);
 284                 RestResponse atomicInstanceForService = createAtomicInstanceForService(serviceDetails_01, atomicResource, user);
 285                 ResourceRestUtils.checkCreateResponse(atomicInstanceForService);
 286         }
 287
 288         private RestResponse createCheckedinVFInstance(ServiceReqDetails containerDetails,
 289                         ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 290                 changeResourceLifecycleState(compInstOriginDetails, modifier.getUserId(), LifeCycleStatesEnum.CHECKIN);
 291                 return createVFInstance(containerDetails, compInstOriginDetails, modifier);
 292         }
 293
 294         private RestResponse createVFInstance(ServiceReqDetails containerDetails, ResourceReqDetails compInstOriginDetails,
 295                         User modifier) throws Exception {
 296                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE,
 297                                 true);
 298         }
 299
 300         private RestResponse createAtomicInstanceForService(ServiceReqDetails containerDetails,
 301                         ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 302                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE,
 303                                 true);
 304         }
 305
 306         private RestResponse createComponentInstance(ComponentReqDetails containerDetails,
 307                         ComponentReqDetails compInstOriginDetails, User modifier, ComponentTypeEnum containerComponentTypeEnum,
 308                         boolean isHighestLevel) throws IOException, Exception {
 309                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory
 310                                 .getComponentResourceInstance(compInstOriginDetails);
 311                 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(
 312                                 resourceInstanceReqDetails, modifier, containerDetails.getUniqueId(), containerComponentTypeEnum);
 313                 return createResourceInstanceResponse;
 314         }
 315
 316         private void changeResourceLifecycleState(ResourceReqDetails resourceDetails, String userUserId,
 317                         LifeCycleStatesEnum lifeCycleStates) throws Exception {
 318                 RestResponse response = LifecycleRestUtils.changeResourceState(resourceDetails, userUserId, lifeCycleStates);
 319                 LifecycleRestUtils.checkLCS_Response(response);
 320         }
 321
 322         private void createAtomicResource(ResourceReqDetails resourceDetails) throws Exception {
 323                 RestResponse createResourceResponse = ResourceRestUtils.createResource(resourceDetails, sdncDesignerDetails);
 324                 ResourceRestUtils.checkCreateResponse(createResourceResponse);
 325
 326         }
 327
 328         private void createVF(ResourceReqDetails resourceDetails) throws Exception {
 329                 createVF(resourceDetails, sdncDesignerDetails);
 330
 331         }
 332
 333         private void createVF(ResourceReqDetails resourceDetails, User sdncModifier) throws Exception {
 334                 RestResponse createVfResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifier);
 335                 ResourceRestUtils.checkCreateResponse(createVfResponse);
 336         }
 337
 338         private void createService(ServiceReqDetails serviceDetails) throws Exception {
 339                 createService(serviceDetails, sdncDesignerDetails);
 340         }
 341
 342         private void createService(ServiceReqDetails serviceDetails, User sdncModifier) throws Exception {
 343                 RestResponse createServiceResponse = ServiceRestUtils.createService(serviceDetails, sdncModifier);
 344                 ResourceRestUtils.checkCreateResponse(createServiceResponse);
 345         }
 346
 347         private void importVfWithArtifacts(ImportReqDetails resourceDetailsVF_01) throws Exception {
 348                 String payloadName = "VF_RI2_G4_withArtifacts.csar";
 349                 Path path = Paths.get(rootPath + "/src/main/resources/ci/VF_RI2_G4_withArtifacts.csar");
 350                 byte[] data = Files.readAllBytes(path);
 351                 String payloadData = Base64.encodeBase64String(data);
 352                 resourceDetailsVF_01.setPayloadData(payloadData);
 353
 354                 resourceDetailsVF_01.setPayloadName(payloadName);
 355                 resourceDetailsVF_01.setResourceType(ResourceTypeEnum.VF.name());
 356                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetailsVF_01, sdncDesignerDetails);
 357                 BaseRestUtils.checkCreateResponse(createResource);
 358         }
 359
 360 }