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