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

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