test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportToscaCapabilitiesWithProperties.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.imports;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertTrue;
  25
  26 import java.io.IOException;
  27 import java.nio.file.Files;
  28 import java.nio.file.Path;
  29 import java.nio.file.Paths;
  30 import java.util.ArrayList;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.stream.Collectors;
  34
  35 import org.apache.commons.codec.binary.Base64;
  36 import org.apache.commons.lang3.tuple.ImmutablePair;
  37 import org.junit.Rule;
  38 import org.junit.rules.TestName;
  39 import org.openecomp.sdc.be.dao.api.ActionStatus;
  40 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  41 import org.openecomp.sdc.be.model.CapabilityDefinition;
  42 import org.openecomp.sdc.be.model.ComponentInstance;
  43 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  44 import org.openecomp.sdc.be.model.Resource;
  45 import org.openecomp.sdc.be.model.User;
  46 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  47 import org.openecomp.sdc.ci.tests.datatypes.ImportReqDetails;
  48 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  49 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  50 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  51 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  52 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  53 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  54 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  55 import org.testng.annotations.Test;
  56
  57 import com.google.gson.Gson;
  58
  59 /**
  60  * US US730518 Story [BE] - TOSCA capabilities with properties - import "As a
  61  * resource designer, I would like to add my VFC capabilities with properties."
  62  *
  63  * @author ns019t
  64  *
  65  */
  66 public class ImportToscaCapabilitiesWithProperties extends ComponentBaseTest {
  67         @Rule
  68         public static TestName name = new TestName();
  69
  70         Gson gson = new Gson();
  71
  72         /**
  73          * public Constructor ImportToscaCapabilitiesWithProperties
  74          */
  75         public ImportToscaCapabilitiesWithProperties() {
  76                 super(name, ImportToscaCapabilitiesWithProperties.class.getName());
  77         }
  78
  79         /**
  80          * String constants
  81          */
  82         public static String propertyForTestName = "propertyfortest";
  83         public static String rootPath = System.getProperty("user.dir");
  84         public static String scalable = "tosca.capabilities.Scalable";
  85         public static String container = "tosca.capabilities.Container";
  86         public static String minInstances = "min_instances";
  87         public static String userDefinedNodeYaml = "mycompute.yml";
  88
  89         /**
  90          * Capability Type - capability type on the graph should already have
  91          * properties modeled on it. please verify. The import of the capability
  92          * types should support adding those properties. when importing, validate
  93          * name uniqueness between the capability's properties see capability
  94          * tosca.capabilities.Container
  95          *
  96          * Acceptance Criteria: validate capability type properties (for example,
  97          * compute have capability Container -> the properties of this capability
  98          * should be in the Json response)
  99          *
 100          * @throws IOException
 101          */
 102         @Test
 103         public void validateCapabilityTypePropertiesSucceed() throws IOException {
 104                 User user = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 105                 RestResponse createResourceRes = ResourceRestUtils.getResourceByNameAndVersion(user.getUserId(), "Compute",
 106                                 "1.0");
 107                 BaseRestUtils.checkSuccess(createResourceRes);
 108                 Resource resource = ResponseParser.convertResourceResponseToJavaObject(createResourceRes.getResponse());
 109                 Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
 110                 assertEquals(capabilities.size(), 6);
 111
 112                 CapabilityDefinition capability = capabilities.get(scalable).get(0);
 113                 List<ComponentInstanceProperty> properties = capability.getProperties();
 114                 assertEquals(properties.size(), 3);
 115                 assertTrue(!properties.stream().filter(p -> p.getName().equalsIgnoreCase(propertyForTestName)).findAny()
 116                                 .isPresent());
 117
 118                 ComponentInstanceProperty originalProperty = properties.stream()
 119                                 .filter(p -> p.getName().equalsIgnoreCase(minInstances)).findAny().get();
 120                 assertEquals(originalProperty.getType(), "integer");
 121                 assertEquals(originalProperty.getDefaultValue(), "1");
 122
 123                 capability = capabilities.get(container).get(0);
 124                 properties = capability.getProperties();
 125                 assertEquals(properties.size(), 4);
 126         }
 127
 128         /**
 129          * Capability Definition on VFC / CP / VL - properties can also be defined
 130          * on the capability when the capability is declared. (property definition
 131          * with default value) If the property name (case insensitive) already
 132          * defined on the capability type, it overrides the capability from the
 133          * capability type Import of VFC / CP /VL should support adding properties
 134          * to the capability. when importing, validate name uniqueness between the
 135          * capability's properties
 136          *
 137          * Acceptance Criteria: import node type with capability definition on it.
 138          * use the attached "myCompute"
 139          *
 140          * @throws Exception
 141          */
 142         @Test
 143         public void importNodeTypeWithCapabilityWithPropertiesFromYmlSucceed() throws Exception {
 144                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 145                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 146                 RestResponse createResource = importUserDefinedNodeType(userDefinedNodeYaml, sdncModifierDetails,
 147                                 resourceDetails);
 148                 BaseRestUtils.checkCreateResponse(createResource);
 149                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 150
 151                 Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
 152                 assertEquals(capabilities.size(), 6);
 153
 154                 CapabilityDefinition capability = capabilities.get(scalable).get(0);
 155                 List<ComponentInstanceProperty> properties = capability.getProperties();
 156                 assertEquals(properties.size(), 4);
 157
 158                 ComponentInstanceProperty newProperty = properties.stream()
 159                                 .filter(p -> p.getName().equalsIgnoreCase(propertyForTestName)).findAny().get();
 160                 assertEquals(newProperty.getType(), "string");
 161                 assertEquals(newProperty.getDescription(), "test");
 162                 assertEquals(newProperty.getDefaultValue(), "success");
 163
 164                 ComponentInstanceProperty overriddenProperty = properties.stream()
 165                                 .filter(p -> p.getName().equalsIgnoreCase(minInstances)).collect(Collectors.toList()).get(0);
 166                 assertEquals(overriddenProperty.getType(), "integer");
 167                 assertEquals(overriddenProperty.getDefaultValue(), "3");
 168
 169         }
 170
 171         /**
 172          * importNodeTypeWithCapabilityWithPropertiesFromYmlFailed
 173          *
 174          * @throws Exception
 175          */
 176         @Test
 177         public void importNodeTypeWithCapabilityWithPropertiesFromYmlFailed() throws Exception {
 178                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 179                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 180                 RestResponse createResource = importUserDefinedNodeType("mycompute_failed.yml", sdncModifierDetails,
 181                                 resourceDetails);
 182                 BaseRestUtils.checkErrorMessageResponse(createResource, ActionStatus.PROPERTY_NAME_ALREADY_EXISTS);
 183         }
 184
 185         /**
 186          * Capability Assignment (on node_template / resource instance) - should
 187          * support assignment of the property (property value). On the resource
 188          * instance level, value can be assigned to either properties that are
 189          * defined on the capability type or on the capability definition. When
 190          * importing a VF - the node_template can have capability's property value.
 191          * It should be imported and saved on the graph Acceptance Criteria: import
 192          * a VF that assign values to property of capability that was defined on the
 193          * capability type
 194          *
 195          * @throws Exception
 196          */
 197         @Test
 198         public void importResourceWithCapabilityWithPropertiesOverridingCapTypePropertiesSucceed() throws Exception {
 199                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 200                 String payloadName = "vf_with_cap_prop_override_cap_type_prop.csar";
 201                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 202                 Path path = Paths.get(rootPath + "/src/test/resources/CI/csars/vf_with_cap_prop_override_cap_type_prop.csar");
 203                 byte[] data = Files.readAllBytes(path);
 204                 String payloadData = Base64.encodeBase64String(data);
 205                 resourceDetails.setPayloadData(payloadData);
 206
 207                 resourceDetails.setPayloadName(payloadName);
 208                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 209                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 210                 BaseRestUtils.checkCreateResponse(createResource);
 211
 212                 List<ImmutablePair<String, String>> propertyNamesValues = new ArrayList<>();
 213                 propertyNamesValues.add(new ImmutablePair<String, String>("num_cpus", "2"));
 214                 propertyNamesValues.add(new ImmutablePair<String, String>("mem_size", "2000 MB"));
 215                 checkResource(createResource, 8, container, "DBMS", propertyNamesValues);
 216
 217                 ResourceReqDetails resourceDetails2 = ElementFactory.getDefaultResource();
 218                 resourceDetails2.setCsarUUID("vf_with_cap_prop_override_cap_type_prop.csar");
 219                 resourceDetails2.setResourceType(ResourceTypeEnum.VF.name());
 220                 createResource = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
 221                 BaseRestUtils.checkCreateResponse(createResource);
 222
 223                 checkResource(createResource, 8, container, "DBMS", propertyNamesValues);
 224         }
 225
 226         /**
 227          * importResourceWithCapabilityWithPropertiesOverridingCapTypePropertiesFailed
 228          *
 229          * @throws Exception
 230          */
 231         @Test
 232         public void importResourceWithCapabilityWithPropertiesOverridingCapTypePropertiesFailed() throws Exception {
 233                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 234                 String payloadName = "vf_with_cap_prop_override_cap_type_prop_failed.csar";
 235                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 236                 Path path = Paths
 237                                 .get(rootPath + "/src/test/resources/CI/csars/vf_with_cap_prop_override_cap_type_prop_failed.csar");
 238                 byte[] data = Files.readAllBytes(path);
 239                 String payloadData = Base64.encodeBase64String(data);
 240                 resourceDetails.setPayloadData(payloadData);
 241
 242                 resourceDetails.setPayloadName(payloadName);
 243                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 244                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 245                 BaseRestUtils.checkErrorMessageResponse(createResource, ActionStatus.INVALID_PROPERTY);
 246
 247                 ResourceReqDetails resourceDetails2 = ElementFactory.getDefaultResource();
 248                 resourceDetails2.setCsarUUID("vf_with_cap_prop_override_cap_type_prop_failed.csar");
 249                 resourceDetails2.setResourceType(ResourceTypeEnum.VF.name());
 250                 createResource = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
 251                 BaseRestUtils.checkErrorMessageResponse(createResource, ActionStatus.INVALID_PROPERTY);
 252
 253         }
 254
 255         /**
 256          * Capability Assignment (on node_template / resource instance) - should
 257          * support assignment of the property (property value). On the resource
 258          * instance level, value can be assigned to either properties that are
 259          * defined on the capability type or on the capability definition. When
 260          * importing a VF - the node_template can have capability's property value.
 261          * It should be imported and saved on the graph Acceptance Criteria: import
 262          * a VF that assign values to property of capability that was defined on the
 263          * capability definition (on the node type)
 264          *
 265          * @throws Exception
 266          */
 267         @Test
 268         public void importResourceWithCapabilityWithPropertiesOverridingNodeTypeCapPropertiesSucceed() throws Exception {
 269
 270                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 271                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 272                 RestResponse createResource = importUserDefinedNodeType(userDefinedNodeYaml, sdncModifierDetails,
 273                                 resourceDetails);
 274                 BaseRestUtils.checkCreateResponse(createResource);
 275                 Resource userDefinedNodeType = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(),
 276                                 Resource.class);
 277
 278                 String payloadName = "vf_with_cap_prop_override_cap_type_prop1.csar";
 279                 resourceDetails = ElementFactory.getDefaultImportResource();
 280                 Path path = Paths.get(rootPath + "/src/test/resources/CI/csars/vf_with_cap_prop_override_cap_type_prop1.csar");
 281                 byte[] data = Files.readAllBytes(path);
 282                 String payloadData = Base64.encodeBase64String(data);
 283                 resourceDetails.setPayloadData(payloadData);
 284
 285                 resourceDetails.setPayloadName(payloadName);
 286                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 287                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 288                 BaseRestUtils.checkCreateResponse(createResource);
 289
 290                 List<ImmutablePair<String, String>> propertyNamesValues = new ArrayList<>();
 291                 propertyNamesValues.add(new ImmutablePair<String, String>("num_cpus", "2"));
 292                 propertyNamesValues.add(new ImmutablePair<String, String>("mem_size", "2000 MB"));
 293                 checkResource(createResource, 8, container, "DBMS", propertyNamesValues);
 294
 295                 List<ImmutablePair<String, String>> propertyNamesValues1 = new ArrayList<>();
 296                 propertyNamesValues1.add(new ImmutablePair<String, String>(propertyForTestName, "success_again"));
 297                 propertyNamesValues1.add(new ImmutablePair<String, String>(minInstances, "4"));
 298                 checkResource(createResource, 8, scalable, userDefinedNodeType.getName(), propertyNamesValues1);
 299
 300                 ResourceReqDetails resourceDetails2 = ElementFactory.getDefaultResource();
 301                 resourceDetails2.setCsarUUID("vf_with_cap_prop_override_cap_type_prop1.csar");
 302                 resourceDetails2.setResourceType(ResourceTypeEnum.VF.name());
 303                 createResource = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
 304                 BaseRestUtils.checkCreateResponse(createResource);
 305
 306                 checkResource(createResource, 8, container, "DBMS", propertyNamesValues);
 307                 checkResource(createResource, 8, scalable, userDefinedNodeType.getName(), propertyNamesValues1);
 308
 309         }
 310
 311         /**
 312          * importResourceWithCapabilityWithPropertiesOverridingNodeTypeCapPropertiesFailed
 313          *
 314          * @throws Exception
 315          */
 316         @Test
 317         public void importResourceWithCapabilityWithPropertiesOverridingNodeTypeCapPropertiesFailed() throws Exception {
 318
 319                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 320                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 321                 RestResponse createResource = importUserDefinedNodeType(userDefinedNodeYaml, sdncModifierDetails,
 322                                 resourceDetails);
 323                 BaseRestUtils.checkCreateResponse(createResource);
 324
 325                 String payloadName = "vf_with_cap_prop_override_cap_type_prop1_failed.csar";
 326                 resourceDetails = ElementFactory.getDefaultImportResource();
 327                 Path path = Paths
 328                                 .get(rootPath + "/src/test/resources/CI/csars/vf_with_cap_prop_override_cap_type_prop1_failed.csar");
 329                 byte[] data = Files.readAllBytes(path);
 330                 String payloadData = Base64.encodeBase64String(data);
 331                 resourceDetails.setPayloadData(payloadData);
 332
 333                 resourceDetails.setPayloadName(payloadName);
 334                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 335                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 336                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.PROPERTY_NAME_ALREADY_EXISTS,
 337                                 propertyForTestName);
 338
 339                 ResourceReqDetails resourceDetails2 = ElementFactory.getDefaultResource();
 340                 resourceDetails2.setCsarUUID("vf_with_cap_prop_override_cap_type_prop1_failed.csar");
 341                 resourceDetails2.setResourceType(ResourceTypeEnum.VF.name());
 342                 createResource = ResourceRestUtils.createResource(resourceDetails2, sdncModifierDetails);
 343                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.PROPERTY_NAME_ALREADY_EXISTS,
 344                                 propertyForTestName);
 345         }
 346
 347         private RestResponse importUserDefinedNodeType(String payloadName, User sdncModifierDetails,
 348                         ImportReqDetails resourceDetails) throws Exception {
 349
 350                 Path path = Paths.get(rootPath + "/src/test/resources/CI/csars/" + payloadName);
 351                 byte[] data = Files.readAllBytes(path);
 352                 String payloadData = Base64.encodeBase64String(data);
 353                 resourceDetails.setPayloadData(payloadData);
 354
 355                 resourceDetails.setPayloadName(payloadName);
 356                 resourceDetails.setResourceType(ResourceTypeEnum.VFC.name());
 357                 return ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 358         }
 359
 360         // TODO Tal: Since Cashing change partial resource returned that causes null
 361         // pointer exception
 362         // commented out till fixing
 363         private void checkResource(RestResponse createResource, int capNum, String capType, String riName,
 364                         List<ImmutablePair<String, String>> propertyNamesValues) {
 365                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 366
 367                 Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
 368                 // TODO Tal: Since Cashing change partial resource returned that causes
 369                 // null pointer exception
 370                 /* assertEquals(capabilities.size(), capNum); */
 371                 /*
 372                  * List<CapabilityDefinition> capabilitesContainer =
 373                  * capabilities.get(capType);
 374                  */
 375
 376                 ComponentInstance resourceRI = resource.getComponentInstances().stream()
 377                                 .filter(ri -> ri.getComponentName().equals(riName)).collect(Collectors.toList()).get(0);
 378                 // TODO Tal: Since Cashing change partial resource returned that causes
 379                 // null pointer exception
 380                 /*
 381                  * CapabilityDefinition capabilityFromContainer =
 382                  * capabilitesContainer.stream()
 383                  * .filter(cap->cap.getOwnerId().equals(resourceRI.getUniqueId())).
 384                  * collect(Collectors.toList()).get(0);
 385                  */
 386
 387                 CapabilityDefinition capabilityFromRI = resourceRI.getCapabilities().get(capType).get(0);
 388                 for (ImmutablePair<String, String> propValuePair : propertyNamesValues) {
 389                         // TODO Tal: Since Cashing change partial resource returned that
 390                         // causes null pointer exception
 391                         /*
 392                          * Map<String, ComponentInstanceProperty> propertiesFromContainer =
 393                          * capabilityFromContainer.getProperties()
 394                          * .stream().filter(p->p.getName().equalsIgnoreCase(propValuePair.
 395                          * getLeft())) .collect(Collectors.toMap(p->p.getName(), p->p));
 396                          */
 397
 398                         List<ComponentInstanceProperty> propertiesFromRI = capabilityFromRI.getProperties().stream()
 399                                         .filter(p -> p.getName().equalsIgnoreCase(propValuePair.getLeft())).collect(Collectors.toList());
 400                         // TODO Tal: Since Cashing change partial resource returned that
 401                         // causes null pointer exception
 402                         /*
 403                          * for(ComponentInstanceProperty riProp : propertiesFromRI){
 404                          * assertTrue(propertiesFromContainer.containsKey(riProp.getName()))
 405                          * ; ComponentInstanceProperty containerProp =
 406                          * propertiesFromContainer.get(riProp.getName());
 407                          * assertEquals(riProp.getValue(), containerProp.getValue());
 408                          * if(riProp.getName().equals(propValuePair.getLeft()))
 409                          * assertEquals(riProp.getValue(), propValuePair.getRight());
 410                          *
 411                          * }
 412                          */
 413                 }
 414         }
 415
 416 }