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