gerrit.onap Code Review - sdc.git/blob

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