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