openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3 import static org.openecomp.sdc.generator.util.GeneratorConstants.ALLOWED_FLAVORS_PROPERTY;
   4 import static org.openecomp.sdc.generator.util.GeneratorConstants.PORT_NODE_TEMPLATE_ID_SUFFIX;
   5 import static org.openecomp.sdc.tosca.services.ToscaConstants.BINDING_REQUIREMENT_ID;
   6 import static org.openecomp.sdc.tosca.services.ToscaConstants.COUNT_PROPERTY_NAME;
   7 import static org.openecomp.sdc.tosca.services.ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME;
   8 import static org.openecomp.sdc.tosca.services.ToscaConstants.SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME;
   9 import static org.openecomp.sdc.translator.services.heattotosca.Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME;
  10
  11 import org.junit.Assert;
  12 import org.junit.Test;
  13 import org.openecomp.sdc.generator.core.utils.GeneratorUtils;
  14 import org.openecomp.sdc.generator.datatypes.tosca.ComputeFlavor;
  15 import org.openecomp.sdc.generator.datatypes.tosca.DeploymentFlavorModel;
  16 import org.openecomp.sdc.generator.datatypes.tosca.LicenseFlavor;
  17 import org.openecomp.sdc.generator.datatypes.tosca.MultiFlavorVfcImage;
  18 import org.openecomp.sdc.generator.datatypes.tosca.VendorInfo;
  19 import org.openecomp.sdc.generator.datatypes.tosca.VspModelInfo;
  20 import org.openecomp.sdc.generator.util.GeneratorConstants;
  21 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  22 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  23 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  24 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  25 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
  26 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  27 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  28 import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
  29 import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
  30 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  31 import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition;
  32 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  33 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
  34 import org.openecomp.sdc.tosca.services.ToscaConstants;
  35 import org.openecomp.sdc.tosca.services.ToscaUtil;
  36 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  37 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
  38 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  39
  40 import java.util.ArrayList;
  41 import java.util.HashMap;
  42 import java.util.List;
  43 import java.util.Map;
  44
  45 public class ManualVspToscaManagerImplTest {
  46
  47   private static final String COMPONENT_ID = "Component_id";
  48   private static final String COMPONENT_NAME = "Component_name";
  49   private static final String SP_PART_NUMBER_1 = "Part_number_123";
  50   private static final String FEATURE_GROUP_ID_1 = "Feature_Group_id_1";
  51   private static final String MANUFACTURER_REF_1 = "Manufacturer_Ref_1";
  52   private static final String VENDOR_MODEL_1 = "VLM_1";
  53   private static final int NUM_CPUS_1 = 1;
  54   private static final String DISK_SIZE_1 = "2GB";
  55   private static final String MEM_SIZE_1 = "8GB";
  56
  57   private static final String SP_PART_NUMBER_2 = "Part_number_345";
  58   private static final String FEATURE_GROUP_ID_2 = "Feature_Group_id_2";
  59   private static final String MANUFACTURER_REF_2 = "Manufacturer_Ref_2";
  60   private static final String VENDOR_MODEL_2 = "VLM_2";
  61   private static final int NUM_CPUS_2 = 4;
  62   private static final String DISK_SIZE_2 = "3GB";
  63   private static final String MEM_SIZE_2 = "2GB";
  64
  65   private static final String IMAGE_VERSION_1 = "3.16.1";
  66   private static final String IMAGE_HASH_1 = "65edfgye3256hjutve";
  67   private static final String IMAGE_FILE_NAME_1 = "image-file-name1";
  68   private static final String IMAGE_FILE_FORMAT_1 = "qcow2";
  69   private static final String IMAGE_VERSION_2 = "3.1.9";
  70   private static final String IMAGE_HASH_2 = "84rtedfe3256hjutaw";
  71   private static final String IMAGE_FILE_NAME_2 = "image-file-name1";
  72   private static final String IMAGE_FILE_FORMAT_2 = "iso";
  73
  74   private ManualVspToscaManager manualVspToscaManager = new ManualVspToscaManagerImpl();
  75
  76   @Test
  77   public void testGenerateToscaInvalidVspId() {
  78     VspModelInfo emptyVspCollectedData = new VspModelInfo();
  79     ToscaServiceModel toscaServiceModel =
  80         manualVspToscaManager.generateToscaModel(emptyVspCollectedData);
  81     Assert.assertNotNull(toscaServiceModel);
  82     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
  83     //Service model should contain only the packed global types
  84     Assert.assertEquals(19, toscaServiceModel.getServiceTemplates().size());
  85   }
  86
  87   @Test
  88   public void testGenerateToscaNoComponent() {
  89     VspModelInfo vspCollectedData = new VspModelInfo();
  90     vspCollectedData.setReleaseVendor("Vendor-1");
  91     vspCollectedData.setComponents(null);
  92     vspCollectedData.setMultiFlavorVfcImages(null);
  93     vspCollectedData.setAllowedFlavors(getDeploymentFlavorData());
  94     vspCollectedData.setNics(getComponentNics());
  95     ToscaServiceModel toscaServiceModel =
  96         manualVspToscaManager.generateToscaModel(vspCollectedData);
  97     Assert.assertNotNull(toscaServiceModel);
  98     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
  99     //Service model should contain only the packed global types
 100     Assert.assertEquals(19, toscaServiceModel.getServiceTemplates().size());
 101   }
 102
 103   @Test
 104   public void testGenerateToscaReleaseVendorNotPresent() {
 105     VspModelInfo vspCollectedData = new VspModelInfo();
 106     vspCollectedData.setComponents(getComponentData());
 107     vspCollectedData.setMultiFlavorVfcImages(getVfcImageData());
 108     vspCollectedData.setAllowedFlavors(getDeploymentFlavorData());
 109     vspCollectedData.setNics(getComponentNics());
 110     ToscaServiceModel toscaServiceModel =
 111         manualVspToscaManager.generateToscaModel(vspCollectedData);
 112     Assert.assertNotNull(toscaServiceModel);
 113     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
 114     //Service model should contain only the packed global types
 115     Assert.assertEquals(22, toscaServiceModel.getServiceTemplates().size());
 116     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
 117     String entryDefinitionServiceTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
 118     ServiceTemplate mainServiceTemplate = serviceTemplates.get(entryDefinitionServiceTemplate);
 119     Assert.assertNotNull(mainServiceTemplate);
 120     Assert.assertNull(mainServiceTemplate.getMetadata().get("releaseVendor"));
 121   }
 122
 123   @Test
 124   public void testGenerateToscaNoImages() {
 125     VspModelInfo vspCollectedData = new VspModelInfo();
 126     vspCollectedData.setComponents(getComponentData());
 127     vspCollectedData.setMultiFlavorVfcImages(null);
 128     vspCollectedData.setAllowedFlavors(getDeploymentFlavorData());
 129     vspCollectedData.setNics(getComponentNics());
 130     ToscaServiceModel toscaServiceModel =
 131         manualVspToscaManager.generateToscaModel(vspCollectedData);
 132     Assert.assertNotNull(toscaServiceModel);
 133     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
 134     //Service model should contain only the packed global types
 135     Assert.assertEquals(22, toscaServiceModel.getServiceTemplates().size());
 136     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
 137     String entryDefinitionServiceTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
 138     ServiceTemplate mainServiceTemplate = serviceTemplates.get(entryDefinitionServiceTemplate);
 139     Assert.assertNotNull(mainServiceTemplate);
 140     String componentName = vspCollectedData.getComponents().get(COMPONENT_ID);
 141     Assert.assertNull(mainServiceTemplate.getTopology_template().getNode_templates()
 142         .get(componentName + GeneratorConstants.VFC_NODE_TEMPLATE_ID_SUFFIX)
 143         .getProperties());
 144   }
 145
 146   @Test
 147   public void testGenerateToscaNoPorts() {
 148     VspModelInfo vspCollectedData = new VspModelInfo();
 149     vspCollectedData.setComponents(getComponentData());
 150     vspCollectedData.setMultiFlavorVfcImages(getVfcImageData());
 151     vspCollectedData.setAllowedFlavors(getDeploymentFlavorData());
 152     vspCollectedData.setNics(null);
 153     ToscaServiceModel toscaServiceModel =
 154         manualVspToscaManager.generateToscaModel(vspCollectedData);
 155     Assert.assertNotNull(toscaServiceModel);
 156     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
 157     //Service model should contain only the packed global types
 158     Assert.assertEquals(22, toscaServiceModel.getServiceTemplates().size());
 159     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
 160     String componentName = vspCollectedData.getComponents().get(COMPONENT_ID);
 161     String substitutionServiceTemplateFileName =
 162         componentName + GeneratorConstants.TOSCA_SERVICE_TEMPLATE_FILE_NAME_SUFFIX;
 163     ServiceTemplate substitutionServiceTemplate =
 164         serviceTemplates.get(substitutionServiceTemplateFileName);
 165     Assert.assertNotNull(substitutionServiceTemplate);
 166     //Only component node template should be present since there are no ports
 167     Assert.assertEquals(1, substitutionServiceTemplate.getTopology_template().getNode_templates()
 168         .size());
 169   }
 170
 171   @Test
 172   public void testGenerateToscaNoManufacturerRefNumAndFeatureGroup() {
 173     VspModelInfo vspCollectedData = new VspModelInfo();
 174     vspCollectedData.setReleaseVendor("Vendor-1");
 175     vspCollectedData.setComponents(getComponentData());
 176     vspCollectedData.setMultiFlavorVfcImages(getVfcImageData());
 177     Map<String, DeploymentFlavorModel> deploymentFlavorData = getDeploymentFlavorData();
 178     deploymentFlavorData.get(SP_PART_NUMBER_1).getVendor_info()
 179         .setManufacturer_reference_number(null);
 180     deploymentFlavorData.get(SP_PART_NUMBER_1).getLicense_flavor().setFeature_group_uuid(null);
 181     vspCollectedData.setAllowedFlavors(deploymentFlavorData);
 182     vspCollectedData.setNics(getComponentNics());
 183     ToscaServiceModel toscaServiceModel =
 184         manualVspToscaManager.generateToscaModel(vspCollectedData);
 185     Assert.assertNotNull(toscaServiceModel);
 186     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
 187     //Service model should contain only the packed global types
 188     Assert.assertEquals(22, toscaServiceModel.getServiceTemplates().size());
 189     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
 190     String entryDefinitionServiceTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
 191     ServiceTemplate mainServiceTemplate = serviceTemplates.get(entryDefinitionServiceTemplate);
 192     Assert.assertNotNull(mainServiceTemplate);
 193     String componentName = vspCollectedData.getComponents().get(COMPONENT_ID);
 194     Map<String, DeploymentFlavorModel> actualDeploymentFlavor = (Map<String, DeploymentFlavorModel>)
 195         mainServiceTemplate.getTopology_template().getNode_templates()
 196         .get(componentName + GeneratorConstants.VNF_CONFIG_NODE_TEMPLATE_ID_SUFFIX)
 197         .getProperties().get(ALLOWED_FLAVORS_PROPERTY);
 198     Assert.assertNull(actualDeploymentFlavor.get(SP_PART_NUMBER_1).getVendor_info()
 199         .getManufacturer_reference_number());
 200     Assert.assertNull(actualDeploymentFlavor.get(SP_PART_NUMBER_1).getLicense_flavor()
 201         .getFeature_group_uuid());
 202   }
 203
 204   @Test
 205   public void testGenerateToscaNoDeploymentFlavor() {
 206     VspModelInfo vspCollectedData = new VspModelInfo();
 207     vspCollectedData.setReleaseVendor("Vendor-1");
 208     vspCollectedData.setComponents(getComponentData());
 209     vspCollectedData.setMultiFlavorVfcImages(getVfcImageData());
 210     vspCollectedData.setAllowedFlavors(null);
 211     vspCollectedData.setNics(getComponentNics());
 212     ToscaServiceModel toscaServiceModel =
 213         manualVspToscaManager.generateToscaModel(vspCollectedData);
 214     Assert.assertNotNull(toscaServiceModel);
 215     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
 216     //Service model should contain only the packed global types
 217     Assert.assertEquals(22, toscaServiceModel.getServiceTemplates().size());
 218     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
 219     String entryDefinitionServiceTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
 220     ServiceTemplate mainServiceTemplate = serviceTemplates.get(entryDefinitionServiceTemplate);
 221     Assert.assertNotNull(mainServiceTemplate);
 222     String componentName = vspCollectedData.getComponents().get(COMPONENT_ID);
 223     Assert.assertNull(mainServiceTemplate.getTopology_template().getNode_templates()
 224         .get(componentName + GeneratorConstants.VNF_CONFIG_NODE_TEMPLATE_ID_SUFFIX)
 225         .getProperties());
 226   }
 227
 228   @Test
 229   public void testGenerateToscaCompleteData() {
 230     VspModelInfo vspCollectedData = new VspModelInfo();
 231     vspCollectedData.setReleaseVendor("Vendor-1");
 232     vspCollectedData.setComponents(getComponentData());
 233     vspCollectedData.setMultiFlavorVfcImages(getVfcImageData());
 234     vspCollectedData.setAllowedFlavors(getDeploymentFlavorData());
 235     vspCollectedData.setNics(getComponentNics());
 236     ToscaServiceModel toscaServiceModel =
 237         manualVspToscaManager.generateToscaModel(vspCollectedData);
 238     Assert.assertNotNull(toscaServiceModel);
 239     Assert.assertNotNull(toscaServiceModel.getServiceTemplates());
 240     //Service model should contain only the packed global types
 241     Assert.assertEquals(22, toscaServiceModel.getServiceTemplates().size());
 242     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
 243     String entryDefinitionServiceTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
 244     ServiceTemplate mainServiceTemplate = serviceTemplates.get(entryDefinitionServiceTemplate);
 245     Assert.assertNotNull(mainServiceTemplate);
 246     String componentName = vspCollectedData.getComponents().get(COMPONENT_ID);
 247
 248     Assert.assertNotNull(mainServiceTemplate.getTopology_template().getNode_templates()
 249         .get(componentName + GeneratorConstants.VFC_NODE_TEMPLATE_ID_SUFFIX));
 250     Assert.assertNotNull(mainServiceTemplate.getTopology_template().getNode_templates()
 251         .get(componentName + GeneratorConstants.VNF_NODE_TEMPLATE_ID_SUFFIX));
 252     //Validate vnf configuration node template
 253     validateVnfConfigurationNodeTemplate(mainServiceTemplate, componentName);
 254     //Validate vfc node template
 255     validateVfcNodeTemplateinMainServiceTemplate(mainServiceTemplate, componentName);
 256     //Validate vnf node template
 257     validateVnfNodeTemplate(mainServiceTemplate, componentName);
 258
 259     //Validate substitution service template
 260     ServiceTemplate substitutionServiceTemplate = toscaServiceModel.getServiceTemplates()
 261         .get(componentName + GeneratorConstants.TOSCA_SERVICE_TEMPLATE_FILE_NAME_SUFFIX);
 262     List<Nic> nics = vspCollectedData.getNics().get(COMPONENT_ID);
 263     validateSubstitutionServiceTemplate(substitutionServiceTemplate, nics, componentName);
 264
 265     //Validate global substitution service template
 266     ServiceTemplate globalSubstitutionServiceTemplate = toscaServiceModel.getServiceTemplates()
 267         .get(ToscaUtil.getServiceTemplateFileName(GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME));
 268     validateGlobalSubstitutionServiceTemplate(globalSubstitutionServiceTemplate, nics,
 269         componentName);
 270   }
 271
 272   private void validateVnfConfigurationNodeTemplate(ServiceTemplate mainServiceTemplate,
 273                                                     String componentName) {
 274     NodeTemplate vnfConfigNodeTemplate =
 275         mainServiceTemplate.getTopology_template().getNode_templates()
 276             .get(componentName + GeneratorConstants.VNF_CONFIG_NODE_TEMPLATE_ID_SUFFIX);
 277     Assert.assertNotNull(vnfConfigNodeTemplate);
 278     Assert.assertEquals(ToscaNodeType.VNF_CONFIG_NODE_TYPE, vnfConfigNodeTemplate.getType());
 279     Map<String, DeploymentFlavorModel> allowedFlavors = (Map<String, DeploymentFlavorModel>)
 280         vnfConfigNodeTemplate.getProperties().get(GeneratorConstants.ALLOWED_FLAVORS_PROPERTY);
 281     Map<String, DeploymentFlavorModel> deploymentFlavorData = getDeploymentFlavorData();
 282     Assert.assertNotNull(allowedFlavors);
 283     Assert.assertEquals(deploymentFlavorData.size(), allowedFlavors.size());
 284     Assert.assertEquals(deploymentFlavorData, allowedFlavors);
 285   }
 286
 287   private void validateVfcNodeTemplateinMainServiceTemplate(ServiceTemplate mainServiceTemplate,
 288                                                             String componentName) {
 289     NodeTemplate vfcNodeTemplate =
 290         mainServiceTemplate.getTopology_template().getNode_templates()
 291             .get(componentName + GeneratorConstants.VFC_NODE_TEMPLATE_ID_SUFFIX);
 292     Assert.assertNotNull(vfcNodeTemplate);
 293     Assert.assertEquals(ToscaNodeType.MULTIFLAVOR_VFC_NODE_TYPE, vfcNodeTemplate.getType());
 294     Map<String, MultiFlavorVfcImage> vfcImages = (Map<String, MultiFlavorVfcImage>)
 295         vfcNodeTemplate.getProperties().get(GeneratorConstants.IMAGES_PROPERTY);
 296     Assert.assertNotNull(vfcImages);
 297     Assert.assertEquals(2, vfcImages.size());
 298     MultiFlavorVfcImage image1 = vfcImages.get(IMAGE_VERSION_1);
 299     MultiFlavorVfcImage expectedImage1 = getImageData(IMAGE_VERSION_1, IMAGE_HASH_1,
 300         IMAGE_FILE_NAME_1, "md5", IMAGE_FILE_FORMAT_1);
 301     Assert.assertEquals(expectedImage1, image1);
 302     MultiFlavorVfcImage image2 = vfcImages.get(IMAGE_VERSION_2);
 303     MultiFlavorVfcImage expectedImage2 = getImageData(IMAGE_VERSION_2, IMAGE_HASH_2,
 304         IMAGE_FILE_NAME_2, "md5", IMAGE_FILE_FORMAT_2);
 305     Assert.assertEquals(expectedImage2, image2);
 306   }
 307
 308   private void validateVnfNodeTemplate(ServiceTemplate mainServiceTemplate,
 309                                        String componentName) {
 310     NodeTemplate vnfNodeTemplate =
 311         mainServiceTemplate.getTopology_template().getNode_templates()
 312             .get(componentName + GeneratorConstants.VNF_NODE_TEMPLATE_ID_SUFFIX);
 313     Assert.assertNotNull(vnfNodeTemplate);
 314     Assert.assertEquals(ToscaNodeType.MULTIDEPLOYMENTFLAVOR_NODE_TYPE + "." + componentName,
 315         vnfNodeTemplate.getType());
 316     Assert.assertNotNull(vnfNodeTemplate.getDirectives());
 317     Assert.assertEquals(true, vnfNodeTemplate.getDirectives().contains(ToscaConstants
 318         .NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE));
 319
 320     Map<String, Object> serviceTemplateFilterProperty = (Map<String, Object>) vnfNodeTemplate
 321         .getProperties().get(SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
 322     Assert.assertNotNull(serviceTemplateFilterProperty);
 323     String substituteServiceTemplate = serviceTemplateFilterProperty
 324             .get(SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME).toString();
 325     String expectedServiceTemplateName = componentName + GeneratorConstants
 326         .TOSCA_SERVICE_TEMPLATE_FILE_NAME_SUFFIX;
 327     Assert.assertEquals(expectedServiceTemplateName, substituteServiceTemplate);
 328     int count = (int) serviceTemplateFilterProperty.get(COUNT_PROPERTY_NAME);
 329     Assert.assertEquals(1, count);
 330   }
 331
 332   private void validateSubstitutionServiceTemplate(ServiceTemplate substitutionServiceTemplate,
 333                                                    List<Nic> nics,
 334                                                    String componentName) {
 335     Assert.assertNotNull(substitutionServiceTemplate);
 336     int expectedNumberOfNodeTemplates = nics.size() + 1; //1 component node template
 337     Map<String, NodeTemplate> substitutionNodeTemplates =
 338         substitutionServiceTemplate.getTopology_template().getNode_templates();
 339     Assert.assertEquals(expectedNumberOfNodeTemplates, substitutionNodeTemplates.size());
 340     NodeTemplate componentNodeTemplate = substitutionNodeTemplates.get(componentName);
 341     Assert.assertNotNull(componentNodeTemplate);
 342     Assert.assertEquals(ToscaNodeType.VFC_NODE_TYPE_PREFIX + componentName, componentNodeTemplate
 343         .getType());
 344     for (Nic nic : nics) {
 345       String nicName = nic.getName();
 346       NodeTemplate nicNodeTemplate =
 347           substitutionNodeTemplates.get(nicName + PORT_NODE_TEMPLATE_ID_SUFFIX);
 348       validateNicNodeTemplate(nicNodeTemplate, componentName);
 349     }
 350     SubstitutionMapping substitutionMappings =
 351         substitutionServiceTemplate.getTopology_template().getSubstitution_mappings();
 352     validateSubstitutionMappings(substitutionMappings, nics, componentName);
 353   }
 354
 355   private void validateNicNodeTemplate(NodeTemplate nicNodeTemplate,
 356                                        String componentName) {
 357     Assert.assertNotNull(nicNodeTemplate);
 358     Assert.assertEquals(ToscaNodeType.NETWORK_PORT, nicNodeTemplate.getType());
 359     List<Map<String, RequirementAssignment>> nicNodeTemplateRequirements =
 360         nicNodeTemplate.getRequirements();
 361     Assert.assertNotNull(nicNodeTemplateRequirements);
 362     Assert.assertEquals(1, nicNodeTemplateRequirements.size());
 363     RequirementAssignment expectedRequirementAssignment = new RequirementAssignment();
 364     expectedRequirementAssignment.setCapability(ToscaCapabilityType.NATIVE_NETWORK_BINDABLE);
 365     expectedRequirementAssignment.setRelationship(ToscaRelationshipType.NATIVE_NETWORK_BINDS_TO);
 366     expectedRequirementAssignment.setNode(componentName);
 367     Assert.assertEquals(true, new ToscaAnalyzerServiceImpl()
 368         .isRequirementExistInNodeTemplate(nicNodeTemplate, BINDING_REQUIREMENT_ID,
 369             expectedRequirementAssignment));
 370   }
 371
 372   private void validateSubstitutionMappings(SubstitutionMapping substitutionMappings,
 373                                             List<Nic> nics,
 374                                             String componentName) {
 375     Assert.assertEquals(ToscaNodeType.MULTIDEPLOYMENTFLAVOR_NODE_TYPE + "." + componentName,
 376         substitutionMappings.getNode_type());
 377     Map<String, List<String>> capabilities = substitutionMappings.getCapabilities();
 378     validateSubstitutionCapabilities(capabilities, componentName);
 379     Map<String, List<String>> requirements = substitutionMappings.getRequirements();
 380     validateSubstitutionRequirements(requirements, nics);
 381   }
 382
 383   private void validateSubstitutionCapabilities(Map<String, List<String>> capabilities,
 384                                                 String componentName) {
 385     List<String> supportedCapabilities = GeneratorUtils.supportedCapabilities;
 386     Assert.assertEquals(supportedCapabilities.size(), capabilities.size());
 387     for (String capability : supportedCapabilities) {
 388       String expectedCapabilityId = capability + "_" + componentName;
 389       Assert.assertEquals(true, capabilities.containsKey(expectedCapabilityId));
 390       List<String> expectedCapabilityValue = new ArrayList<>(2);
 391       expectedCapabilityValue.add(componentName);
 392       expectedCapabilityValue.add(capability);
 393       List<String> actualCapabilityValue = capabilities.get(expectedCapabilityId);
 394       Assert.assertEquals(expectedCapabilityValue, actualCapabilityValue);
 395     }
 396   }
 397
 398   private void validateSubstitutionRequirements(Map<String, List<String>> requirements,
 399                                                 List<Nic> nics) {
 400     List<String> supportedRequirements = GeneratorUtils.supportedRequirements;
 401     for(Nic nic : nics) {
 402       String nicNodeTemplateId = nic.getName() + PORT_NODE_TEMPLATE_ID_SUFFIX;
 403       for (String requirement : supportedRequirements) {
 404         String expectedRequirementId = requirement + "_" + nicNodeTemplateId;
 405         Assert.assertEquals(true, requirements.containsKey(expectedRequirementId));
 406         List<String> expectedRequirementValue = new ArrayList<>(2);
 407         expectedRequirementValue.add(nicNodeTemplateId);
 408         expectedRequirementValue.add(requirement);
 409         List<String> actualRequirementValue = requirements.get(expectedRequirementId);
 410         Assert.assertEquals(expectedRequirementValue, actualRequirementValue);
 411       }
 412     }
 413   }
 414
 415   private void validateGlobalSubstitutionServiceTemplate(ServiceTemplate
 416                                                                 globalSubstitutionServiceTemplate,
 417                                                          List<Nic> nics,
 418                                                          String componentName) {
 419     Assert.assertNotNull(globalSubstitutionServiceTemplate);
 420     Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
 421     Assert.assertEquals(1, nodeTypes.size());
 422     NodeType deploymentFlavorNodeType =
 423         nodeTypes.get(ToscaNodeType.MULTIDEPLOYMENTFLAVOR_NODE_TYPE + "." + componentName);
 424     Assert.assertNotNull(deploymentFlavorNodeType);
 425     Map<String, PropertyDefinition> properties = deploymentFlavorNodeType.getProperties();
 426     Assert.assertNotNull(properties);
 427     PropertyDefinition numCpusProperty = properties.get(GeneratorConstants.NUM_CPUS);
 428     Assert.assertNotNull(numCpusProperty);
 429     Assert.assertEquals(PropertyType.INTEGER.getDisplayName(), numCpusProperty.getType());
 430     Assert.assertEquals(true, numCpusProperty.getRequired());
 431
 432     PropertyDefinition diskSizeProperty = properties.get(GeneratorConstants.DISK_SIZE);
 433     Assert.assertNotNull(diskSizeProperty);
 434     Assert.assertEquals(PropertyType.SCALAR_UNIT_SIZE.getDisplayName(), diskSizeProperty.getType());
 435     Assert.assertEquals(true, diskSizeProperty.getRequired());
 436
 437     PropertyDefinition memSizeProperty = properties.get(GeneratorConstants.MEM_SIZE);
 438     Assert.assertNotNull(memSizeProperty);
 439     Assert.assertEquals(PropertyType.SCALAR_UNIT_SIZE.getDisplayName(), memSizeProperty.getType());
 440     Assert.assertEquals(true, memSizeProperty.getRequired());
 441
 442     List<Map<String, RequirementDefinition>> requirements =
 443         deploymentFlavorNodeType.getRequirements();
 444     List<String> supportedRequirements = GeneratorUtils.supportedRequirements;
 445     for (Nic nic : nics) {
 446       boolean found = false;
 447       String nicNodeTemplateId = nic.getName() + PORT_NODE_TEMPLATE_ID_SUFFIX;
 448       for (String requirementId : supportedRequirements) {
 449         String expectedRequirementId = requirementId + "_" + nicNodeTemplateId;
 450         for (Map<String, RequirementDefinition> requirement : requirements) {
 451           if (requirement.containsKey(expectedRequirementId)) {
 452             found = true;
 453             break;
 454           }
 455         }
 456       }
 457       Assert.assertEquals(true, found);
 458     }
 459
 460     Map<String, CapabilityDefinition> capabilities = deploymentFlavorNodeType.getCapabilities();
 461     List<String> supportedCapabilities = GeneratorUtils.supportedCapabilities;
 462     for (String capabilityId : supportedCapabilities) {
 463       String expectedCapabilityId = capabilityId + "_" + componentName;
 464       Assert.assertEquals (true, capabilities.containsKey(expectedCapabilityId));
 465     }
 466   }
 467
 468   private Map<String, String> getComponentData() {
 469     Map<String, String> componentData = new HashMap<>();
 470     componentData.put(COMPONENT_ID, COMPONENT_NAME);
 471     return componentData;
 472   }
 473
 474   private Map<String, List<MultiFlavorVfcImage>> getVfcImageData() {
 475     Map<String, List<MultiFlavorVfcImage>> imageData = new HashMap<>();
 476     List<MultiFlavorVfcImage> images = new ArrayList<>(2);
 477     MultiFlavorVfcImage image1 = getImageData(IMAGE_VERSION_1, IMAGE_HASH_1, IMAGE_FILE_NAME_1,
 478         "md5", IMAGE_FILE_FORMAT_1);
 479     MultiFlavorVfcImage image2 = getImageData(IMAGE_VERSION_2, IMAGE_HASH_2, IMAGE_FILE_NAME_2,
 480         "md5", IMAGE_FILE_FORMAT_2);
 481     images.add(image1);
 482     images.add(image2);
 483     imageData.put(COMPONENT_ID, images);
 484     return imageData;
 485   }
 486
 487   private Map<String, DeploymentFlavorModel> getDeploymentFlavorData() {
 488     Map<String, DeploymentFlavorModel> deploymentFlavorData = new HashMap<>();
 489     ComputeFlavor computeFlavor1 = getComputeFlavorData(NUM_CPUS_1, DISK_SIZE_1, MEM_SIZE_1);
 490     LicenseFlavor licenseFlavor1 = getLicenseFlavor(FEATURE_GROUP_ID_1);
 491     VendorInfo vendorInfo1 = getVendorInfo(MANUFACTURER_REF_1, VENDOR_MODEL_1);
 492     DeploymentFlavorModel deploymentFlavor1 = getDeploymentFlavorModel(SP_PART_NUMBER_1,
 493         computeFlavor1, vendorInfo1, licenseFlavor1);
 494
 495     ComputeFlavor computeFlavor2 = getComputeFlavorData(NUM_CPUS_2, DISK_SIZE_2, MEM_SIZE_2);
 496     LicenseFlavor licenseFlavor2 = getLicenseFlavor(FEATURE_GROUP_ID_2);
 497     VendorInfo vendorInfo2 = getVendorInfo(MANUFACTURER_REF_2, VENDOR_MODEL_2);
 498
 499     DeploymentFlavorModel deploymentFlavor2 = getDeploymentFlavorModel(SP_PART_NUMBER_2,
 500         computeFlavor2, vendorInfo2, licenseFlavor2);
 501
 502     deploymentFlavorData.put(SP_PART_NUMBER_1, deploymentFlavor1);
 503     deploymentFlavorData.put(SP_PART_NUMBER_2, deploymentFlavor2);
 504     return deploymentFlavorData;
 505   }
 506
 507   private DeploymentFlavorModel getDeploymentFlavorModel(String spPartNumber, ComputeFlavor
 508       computeFlavor, VendorInfo vendorInfo, LicenseFlavor licenseFlavor) {
 509     DeploymentFlavorModel deploymentFlavor = new DeploymentFlavorModel();
 510     deploymentFlavor.setSp_part_number(spPartNumber);
 511     deploymentFlavor.setCompute_flavor(computeFlavor);
 512     deploymentFlavor.setLicense_flavor(licenseFlavor);
 513     deploymentFlavor.setVendor_info(vendorInfo);
 514     return deploymentFlavor;
 515   }
 516
 517   private ComputeFlavor getComputeFlavorData(int numCpus, String diskSize, String memSize ) {
 518     ComputeFlavor computeFlavor = new ComputeFlavor();
 519     computeFlavor.setNum_cpus(numCpus);
 520     computeFlavor.setDisk_size(diskSize);
 521     computeFlavor.setMem_size(memSize);
 522     return computeFlavor;
 523   }
 524
 525   private VendorInfo getVendorInfo(String manufacturerRefNumber, String vlmId) {
 526     VendorInfo vendorInfo = new VendorInfo();
 527     vendorInfo.setManufacturer_reference_number(manufacturerRefNumber);
 528     vendorInfo.setVendor_model(vlmId);
 529     return vendorInfo;
 530   }
 531
 532   private LicenseFlavor getLicenseFlavor(String featureGroupId) {
 533     LicenseFlavor licenseFlavor = new LicenseFlavor();
 534     licenseFlavor.setFeature_group_uuid(featureGroupId);
 535     return licenseFlavor;
 536   }
 537
 538   private MultiFlavorVfcImage getImageData(String imageVersion, String fileHash, String fileName,
 539                                            String fileHashType, String fileFormat) {
 540     MultiFlavorVfcImage image = new MultiFlavorVfcImage();
 541     image.setSoftware_version(imageVersion);
 542     image.setFile_hash(fileHash);
 543     image.setFile_hash_type(fileHashType);
 544     image.setFile_name(fileName+"-"+IMAGE_VERSION_2+"."+fileFormat);
 545     return image;
 546   }
 547
 548   private Map<String, List<Nic>> getComponentNics() {
 549     Map<String, List<Nic>> nicData = new HashMap<>();
 550     List<Nic> nicList = new ArrayList<>(2);
 551     Nic nic1 = new Nic();
 552     nic1.setName("Nic_1");
 553
 554     Nic nic2 = new Nic();
 555     nic2.setName("Nic_2");
 556
 557     nicList.add(nic1);
 558     nicList.add(nic2);
 559     nicData.put(COMPONENT_ID, nicList);
 560     return nicData;
 561   }
 562 }