gerrit.onap Code Review - sdc.git/blob

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