gerrit.onap Code Review - sdc.git/blob

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