asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/artifacts/HeatEnvArtifact.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.artifacts;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertNotNull;
  25
  26 import java.io.ByteArrayInputStream;
  27 import java.io.InputStream;
  28 import java.util.List;
  29 import java.util.Map;
  30
  31 import org.apache.commons.codec.binary.Base64;
  32 import org.junit.Rule;
  33 import org.junit.rules.TestName;
  34 import org.openecomp.sdc.be.model.ArtifactDefinition;
  35 import org.openecomp.sdc.be.model.ArtifactUiDownloadData;
  36 import org.openecomp.sdc.be.model.ComponentInstance;
  37 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  38 import org.openecomp.sdc.be.model.Resource;
  39 import org.openecomp.sdc.be.model.Service;
  40 import org.openecomp.sdc.be.model.User;
  41 import org.openecomp.sdc.be.model.heat.HeatParameterType;
  42 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  43 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  44 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  45 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  46 import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  47 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  48 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  49 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  50 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  51 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  52 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  53 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  54 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  55 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  56 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  57 import org.testng.annotations.DataProvider;
  58 import org.testng.annotations.Test;
  59 import org.yaml.snakeyaml.Yaml;
  60
  61 import com.google.gson.Gson;
  62
  63 public class HeatEnvArtifact extends ComponentBaseTest {
  64
  65         @Rule
  66         public static TestName name = new TestName();
  67
  68         public HeatEnvArtifact() {
  69                 super(name, HeatEnvArtifact.class.getName());
  70         }
  71
  72         @Test(enabled = true)
  73         public void heatEnvOnResourceFormatTest() throws Exception {
  74
  75                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  76
  77                 Resource createdResource = createVfFromCSAR(sdncModifierDetails, "csarHeatEnv.csar");
  78                 assertNotNull(createdResource);
  79
  80                 RestResponse certifyState = LifecycleRestUtils.changeComponentState(createdResource, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
  81                 BaseRestUtils.checkSuccess(certifyState);
  82
  83                 Resource certifiedResource = ResponseParser.parseToObjectUsingMapper(certifyState.getResponse(), Resource.class);
  84
  85                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService("ciNewtestservice1", ServiceCategoriesEnum.MOBILITY, sdncModifierDetails.getUserId());
  86
  87                 // 2 create service
  88                 RestResponse createServiceResponse = ServiceRestUtils.createService(serviceDetails, sdncModifierDetails);
  89                 ResourceRestUtils.checkCreateResponse(createServiceResponse);
  90                 Service service = ResponseParser.parseToObjectUsingMapper(createServiceResponse.getResponse(), Service.class);
  91
  92                 // 3 create vf instance in service
  93                 ComponentInstanceReqDetails componentInstanceDetails = ElementFactory.getComponentInstance(certifiedResource);
  94                 RestResponse createComponentInstance = ComponentInstanceRestUtils.createComponentInstance(componentInstanceDetails, sdncModifierDetails, service);
  95                 ResourceRestUtils.checkCreateResponse(createComponentInstance);
  96
  97                 RestResponse getService = ServiceRestUtils.getService(service.getUniqueId());
  98                 BaseRestUtils.checkSuccess(getService);
  99                 service = ResponseParser.parseToObjectUsingMapper(getService.getResponse(), Service.class);
 100
 101                 List<ComponentInstance> componentInstances = service.getComponentInstances();
 102                 assertNotNull(componentInstances);
 103                 assertEquals(1, componentInstances.size());
 104
 105                 ComponentInstance vfi = componentInstances.get(0);
 106                 Map<String, ArtifactDefinition> deploymentArtifacts = vfi.getDeploymentArtifacts();
 107                 assertNotNull(deploymentArtifacts);
 108                 assertEquals(4, deploymentArtifacts.size());
 109                 ArtifactDefinition heatEnv = deploymentArtifacts.get("heat0env");
 110                 assertNotNull(heatEnv);
 111
 112                 Map<String, Object> yaml = downloadComponentInstanceYamlFile(service.getUniqueId(), vfi.getUniqueId(), sdncModifierDetails, heatEnv.getUniqueId());
 113                 assertNotNull(yaml);
 114                 Map<String, Object> paramters = (Map<String, Object>) yaml.get("parameters");
 115                 assertNotNull(paramters);
 116                 assertEquals(8, paramters.size());
 117                 assertEquals(null, paramters.get("param8"));
 118                 List<HeatParameterDefinition> heatParameters = heatEnv.getListHeatParameters();
 119                 heatParameters.forEach(p -> {
 120                         assertEquals(p.getCurrentValue(), paramters.get(p.getName()));
 121                 });
 122         }
 123
 124         @Test(enabled = true)
 125         public void noHeatEnvOnResourceFormatTest() throws Exception {
 126                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 127
 128                 Resource createdResource = createVfFromCSAR(sdncModifierDetails, "csarHeatNoEnv.csar");
 129                 assertNotNull(createdResource);
 130
 131                 RestResponse certifyState = LifecycleRestUtils.changeComponentState(createdResource, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 132                 BaseRestUtils.checkSuccess(certifyState);
 133
 134                 Resource certifiedResource = ResponseParser.parseToObjectUsingMapper(certifyState.getResponse(), Resource.class);
 135
 136                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService("ciNewtestservice1", ServiceCategoriesEnum.MOBILITY, sdncModifierDetails.getUserId());
 137
 138                 // 2 create service
 139                 RestResponse createServiceResponse = ServiceRestUtils.createService(serviceDetails, sdncModifierDetails);
 140                 ResourceRestUtils.checkCreateResponse(createServiceResponse);
 141                 Service service = ResponseParser.parseToObjectUsingMapper(createServiceResponse.getResponse(), Service.class);
 142
 143                 // 3 create vf instance in service
 144                 ComponentInstanceReqDetails componentInstanceDetails = ElementFactory.getComponentInstance(certifiedResource);
 145                 RestResponse createComponentInstance = ComponentInstanceRestUtils.createComponentInstance(componentInstanceDetails, sdncModifierDetails, service);
 146                 ResourceRestUtils.checkCreateResponse(createComponentInstance);
 147
 148                 RestResponse getService = ServiceRestUtils.getService(service.getUniqueId());
 149                 BaseRestUtils.checkSuccess(getService);
 150                 service = ResponseParser.parseToObjectUsingMapper(getService.getResponse(), Service.class);
 151
 152                 List<ComponentInstance> componentInstances = service.getComponentInstances();
 153                 assertNotNull(componentInstances);
 154                 assertEquals(1, componentInstances.size());
 155
 156                 ComponentInstance vfi = componentInstances.get(0);
 157                 Map<String, ArtifactDefinition> deploymentArtifacts = vfi.getDeploymentArtifacts();
 158                 assertNotNull(deploymentArtifacts);
 159                 assertEquals(4, deploymentArtifacts.size());
 160                 ArtifactDefinition heatEnv = deploymentArtifacts.get("heat0env");
 161                 assertNotNull(heatEnv);
 162
 163                 Map<String, Object> yaml = downloadComponentInstanceYamlFile(service.getUniqueId(), vfi.getUniqueId(), sdncModifierDetails, heatEnv.getUniqueId());
 164                 assertNotNull(yaml);
 165                 Map<String, Object> paramters = (Map<String, Object>) yaml.get("parameters");
 166                 assertNotNull(paramters);
 167                 assertEquals(8, paramters.size());
 168                 assertEquals(null, paramters.get("param1"));
 169                 assertEquals(null, paramters.get("param2"));
 170                 assertEquals(null, paramters.get("param4"));
 171                 assertEquals(null, paramters.get("param5"));
 172                 assertEquals(null, paramters.get("param7"));
 173                 assertEquals(null, paramters.get("param8"));
 174                 List<HeatParameterDefinition> heatParameters = heatEnv.getListHeatParameters();
 175                 heatParameters.forEach(p -> {
 176                         assertEquals(p.getCurrentValue(), paramters.get(p.getName()));
 177                 });
 178
 179         }
 180
 181         @DataProvider(name = "vfModuleCsar")
 182         public static Object[][] csarNames() {
 183                 return new Object[][] { { "VSPPackage" }, { "csar_1" }, { "csarHeatEnv.csar" } };
 184         }
 185
 186         @Test(dataProvider = "vfModuleCsar")
 187         public void heatEnvOnVfDownloadNoChangesTest(String vfName) throws Exception {
 188                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 189
 190                 System.out.println("Run for vf " + vfName);
 191                 Resource createdResource = createVfFromCSAR(sdncModifierDetails, vfName);
 192                 assertNotNull(createdResource);
 193                 Map<String, ArtifactDefinition> deploymentArtifacts = createdResource.getDeploymentArtifacts();
 194                 assertNotNull(deploymentArtifacts);
 195
 196                 for (ArtifactDefinition artifact : deploymentArtifacts.values()) {
 197                         if (artifact.getArtifactType().equals("HEAT")) {
 198
 199                                 ArtifactDefinition heatArtifact = artifact;
 200                                 assertNotNull(heatArtifact);
 201
 202                                 ArtifactDefinition heatEnvArtifact = deploymentArtifacts.get(artifact.getArtifactLabel() + "env");
 203                                 assertNotNull(heatEnvArtifact);
 204
 205                                 String heatEnvId = heatEnvArtifact.getUniqueId();
 206                                 downloadHeatEnvAndValidate(sdncModifierDetails, createdResource, heatArtifact, heatEnvId);
 207                         }
 208                 }
 209                 System.out.println("Finished for vf " + vfName);
 210
 211         }
 212
 213         private void downloadHeatEnvAndValidate(User sdncModifierDetails, Resource createdResource, ArtifactDefinition heatArtifact, String heatEnvId) throws Exception {
 214                 RestResponse downloadResult = ArtifactRestUtils.downloadResourceArtifactInternalApi(createdResource.getUniqueId(), sdncModifierDetails, heatEnvId);
 215                 BaseRestUtils.checkSuccess(downloadResult);
 216
 217                 ArtifactUiDownloadData artifactUiDownloadData = ResponseParser.parseToObject(downloadResult.getResponse(), ArtifactUiDownloadData.class);
 218                 byte[] fromUiDownload = artifactUiDownloadData.getBase64Contents().getBytes();
 219                 byte[] decodeBase64 = Base64.decodeBase64(fromUiDownload);
 220                 Yaml yaml = new Yaml();
 221
 222                 InputStream inputStream = new ByteArrayInputStream(decodeBase64);
 223
 224                 Map<String, Object> load = (Map<String, Object>) yaml.load(inputStream);
 225                 Map<String, Object> paramters = (Map<String, Object>) load.get("parameters");
 226                 assertNotNull(paramters);
 227
 228                 List<HeatParameterDefinition> heatParameters = heatArtifact.getListHeatParameters();
 229                 assertNotNull(heatParameters);
 230                 assertEquals("Validate heat parameters size", heatParameters.size(), paramters.size());
 231                 Gson gson = new Gson();
 232                 heatParameters.forEach(hpInResource -> {
 233                         Object valueInFile = paramters.get(hpInResource.getName());
 234                         Object valueInResource;
 235                         if (hpInResource.getCurrentValue() == null) {
 236                                 valueInResource = hpInResource.getDefaultValue();
 237                         } else {
 238                                 valueInResource = hpInResource.getCurrentValue();
 239                         }
 240                         if (valueInResource == null) {
 241                                 assertEquals("Validate null value for parameter " + hpInResource.getName(), valueInResource, valueInFile);
 242                         } else {
 243                                 HeatParameterType type = HeatParameterType.isValidType(hpInResource.getType());
 244                                 // if (type != null && (HeatParameterType.JSON == type || HeatParameterType.COMMA_DELIMITED_LIST == type)){
 245                                 // String jsonValue = gson.toJson(valueInFile).toString();
 246                                 //
 247                                 // assertEquals("Validate value as json string for parameter " +hpInResource.getName() ,valueInResource, jsonValue);
 248                                 // }else{
 249                                 assertEquals("Validate value for parameter " + hpInResource.getName(), valueInResource, valueInFile.toString());
 250                                 // }
 251                         }
 252                 });
 253         }
 254
 255         @Test(enabled = true)
 256         public void heatEnvOnVfFailedTest() throws Exception {
 257                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 258
 259                 Resource createdResource = createVfFromCSAR(sdncModifierDetails, "csar_1");
 260                 assertNotNull(createdResource);
 261                 Map<String, ArtifactDefinition> deploymentArtifacts = createdResource.getDeploymentArtifacts();
 262                 assertNotNull(deploymentArtifacts);
 263                 String heatEnvId = "wrongId";
 264                 RestResponse downloadResult = ArtifactRestUtils.downloadResourceArtifactInternalApi(createdResource.getUniqueId(), sdncModifierDetails, heatEnvId);
 265
 266                 assertEquals("Validate error code", 404, downloadResult.getErrorCode().intValue());
 267
 268                 // BaseRestUtils.checkErrorResponse(downloadResult, ActionStatus.ARTIFACT_NOT_FOUND);
 269
 270         }
 271
 272         @Test(dataProvider = "vfModuleCsar")
 273         public void heatEnvOnVfDownloadChangeParamTest(String vfName) throws Exception {
 274                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 275
 276                 Resource createdResource = createVfFromCSAR(sdncModifierDetails, vfName);
 277                 assertNotNull(createdResource);
 278                 Map<String, ArtifactDefinition> deploymentArtifacts = createdResource.getDeploymentArtifacts();
 279                 assertNotNull(deploymentArtifacts);
 280
 281                 ArtifactDefinition heatArt = deploymentArtifacts.get("heat0");
 282                 assertNotNull(heatArt);
 283
 284                 List<HeatParameterDefinition> heatParameters = heatArt.getListHeatParameters();
 285                 assertNotNull(heatParameters);
 286                 HeatParameterDefinition paramForChange = null;
 287                 for (HeatParameterDefinition hp : heatParameters) {
 288                         if (hp.getType().equals("string")) {
 289                                 paramForChange = hp;
 290                                 break;
 291                         }
 292                 }
 293                 assertNotNull(paramForChange);
 294                 paramForChange.setCurrentValue("newValueForTest");
 295                 RestResponse updateResult = ArtifactRestUtils.updateDeploymentArtifactToResource(heatArt, sdncModifierDetails, createdResource.getUniqueId());
 296                 BaseRestUtils.checkSuccess(updateResult);
 297
 298                 RestResponse getResourceResult = ResourceRestUtils.getResource(createdResource.getUniqueId());
 299                 BaseRestUtils.checkSuccess(getResourceResult);
 300
 301                 Resource resource = ResponseParser.convertResourceResponseToJavaObject(getResourceResult.getResponse());
 302                 assertNotNull(resource);
 303                 deploymentArtifacts = resource.getDeploymentArtifacts();
 304                 assertNotNull(deploymentArtifacts);
 305
 306                 heatArt = deploymentArtifacts.get("heat0");
 307                 assertNotNull(heatArt);
 308                 ArtifactDefinition heatEnvArt = deploymentArtifacts.get("heat0env");
 309                 assertNotNull(heatEnvArt);
 310
 311                 downloadHeatEnvAndValidate(sdncModifierDetails, createdResource, heatArt, heatEnvArt.getUniqueId());
 312
 313         }
 314
 315         // ****************************************
 316         private Map<String, Object> downloadComponentInstanceYamlFile(String serviceUniqueId, String resourceInstanceId, User user, String artifactUniqeId) throws Exception {
 317                 RestResponse heatEnvDownloadResponse = ArtifactRestUtils.downloadResourceInstanceArtifact(serviceUniqueId, resourceInstanceId, user, artifactUniqeId);
 318                 BaseRestUtils.checkSuccess(heatEnvDownloadResponse);
 319
 320                 ArtifactUiDownloadData artifactUiDownloadData = ResponseParser.parseToObject(heatEnvDownloadResponse.getResponse(), ArtifactUiDownloadData.class);
 321                 byte[] fromUiDownload = artifactUiDownloadData.getBase64Contents().getBytes();
 322                 byte[] decodeBase64 = Base64.decodeBase64(fromUiDownload);
 323                 Yaml yaml = new Yaml();
 324
 325                 InputStream inputStream = new ByteArrayInputStream(decodeBase64);
 326
 327                 Map<String, Object> load = (Map<String, Object>) yaml.load(inputStream);
 328
 329                 return load;
 330         }
 331 }