src/test/java/org/onap/sdc/impl/ToscaParserNodeTemplateTest.java

   1 package org.onap.sdc.impl;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertFalse;
   5 import static org.testng.Assert.assertNotNull;
   6 import static org.testng.Assert.assertNull;
   7 import static org.testng.Assert.assertTrue;
   8 import java.util.*;
   9 import java.util.stream.Collectors;
  10
  11 import com.google.common.collect.ImmutableMap;
  12 import org.apache.commons.lang3.tuple.Pair;
  13 import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
  14 import org.onap.sdc.tosca.parser.impl.FilterType;
  15 import org.onap.sdc.tosca.parser.impl.SdcTypes;
  16 import org.onap.sdc.toscaparser.api.CapabilityAssignment;
  17 import org.onap.sdc.toscaparser.api.CapabilityAssignments;
  18 import org.onap.sdc.toscaparser.api.Group;
  19 import org.onap.sdc.toscaparser.api.NodeTemplate;
  20 import org.onap.sdc.toscaparser.api.Policy;
  21 import org.onap.sdc.toscaparser.api.Property;
  22 import org.onap.sdc.toscaparser.api.parameters.Annotation;
  23 import org.onap.sdc.toscaparser.api.parameters.Input;
  24 import org.testng.annotations.Test;
  25
  26 public class ToscaParserNodeTemplateTest extends SdcToscaParserBasicTest {
  27
  28         //region getServiceVfList
  29         @Test
  30         public void testNumberOfVfSunnyFlow() throws SdcToscaParserException {
  31                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
  32                 assertNotNull(serviceVfList);
  33                 assertEquals(2, serviceVfList.size());
  34         }
  35
  36         @Test
  37         public void testGetNodeTemplateCustomizationUuid(){
  38                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
  39                 boolean found = false;
  40                 for (NodeTemplate nt : serviceVfList){
  41                         if (nt.getName().equals("FDNT 1")){
  42                                 found = true;
  43                                 assertEquals(fdntCsarHelper.getNodeTemplateCustomizationUuid(nt), "56179cd8-de4a-4c38-919b-bbc4452d2d73");
  44                         }
  45                 }
  46                 assertTrue(found);
  47         }
  48
  49         @Test
  50         public void testSingleVFWithNotMetadata() throws SdcToscaParserException {
  51                 //If there is no metadata on VF level - There is no VF's because the type is taken from metadata values.
  52                 List<NodeTemplate> serviceVfList = rainyCsarHelperSingleVf.getServiceVfList();
  53                 assertNotNull(serviceVfList);
  54                 assertEquals(0, serviceVfList.size());
  55         }
  56         //endregion
  57
  58         //region getNodeTemplatePropertyLeafValue
  59         @Test
  60         public void testNodeTemplateFlatProperty() throws SdcToscaParserException {
  61                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
  62                 assertEquals("2", fdntCsarHelper.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "availability_zone_max_count"));
  63                 assertEquals("3", fdntCsarHelper.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "max_instances"));
  64                 assertEquals("some code", fdntCsarHelper.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "nf_naming_code"));
  65         }
  66
  67         @Test
  68         public void testNodeTemplateFlatFunctionProperty() throws SdcToscaParserException {
  69                 List<NodeTemplate> serviceVfList = fdntCsarHelperWithInputs.getServiceVfList();
  70                 assertEquals(null, fdntCsarHelperWithInputs.getNodeTemplatePropertyLeafValue(serviceVfList.get(1), "target_network_role"));
  71         }
  72
  73         @Test
  74         public void testNodeTemplateNestedFunctionProperty() throws SdcToscaParserException {
  75                 List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
  76                 assertEquals(null, ipAssignCsarHelper.getNodeTemplatePropertyLeafValue(vfcs.get(0), "port_pd01_port_ip_requirements#ip_count_required#count"));
  77         }
  78
  79         @Test
  80         public void testNodeTemplateNestedProperty() throws SdcToscaParserException {
  81                 List<NodeTemplate> serviceVlList = fdntCsarHelper.getServiceVlList();
  82                 NodeTemplate nodeTemplate = serviceVlList.get(0);
  83                 //System.out.println("node template " + nodeTemplate.toString());
  84                 assertEquals("24", fdntCsarHelper.getNodeTemplatePropertyLeafValue(nodeTemplate, "network_assignments#ipv4_subnet_default_assignment#cidr_mask"));
  85                 assertEquals("7a6520b-9982354-ee82992c-105720", fdntCsarHelper.getNodeTemplatePropertyLeafValue(nodeTemplate, "network_flows#vpn_binding"));
  86         }
  87
  88         @Test
  89         public void testNodeTemplateNestedPropertyFromInput() throws SdcToscaParserException {
  90                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
  91                 NodeTemplate nodeTemplate = serviceVfList.get(0);
  92                 //System.out.println("node template " + nodeTemplate.toString());
  93                 assertEquals("true", fdntCsarHelper.getNodeTemplatePropertyLeafValue(nodeTemplate, "nf_naming#ecomp_generated_naming"));
  94                 assertEquals("FDNT_instance_VF_2", fdntCsarHelper.getNodeTemplatePropertyLeafValue(nodeTemplate, "nf_naming#naming_policy"));
  95         }
  96
  97         @Test
  98         public void testNodeTemplateNestedPropertyNotExists() throws SdcToscaParserException {
  99                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
 100                 String nodeTemplatePropertyLeafValue = fdntCsarHelper.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "nf_role#nf_naming#kuku");
 101                 assertNull(nodeTemplatePropertyLeafValue);
 102         }
 103
 104         @Test
 105         public void testNodeTemplateFlatPropertyByNotFoundProperty() throws SdcToscaParserException {
 106                 List<NodeTemplate> serviceVfList = rainyCsarHelperMultiVfs.getServiceVfList();
 107                 String nodeTemplatePropertyLeafValue = rainyCsarHelperMultiVfs.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "XXXX");
 108                 assertNull(nodeTemplatePropertyLeafValue);
 109         }
 110
 111         @Test
 112         public void testNodeTemplateFlatPropertyByNullProperty() throws SdcToscaParserException {
 113                 List<NodeTemplate> serviceVfList = rainyCsarHelperMultiVfs.getServiceVfList();
 114                 String nodeTemplatePropertyLeafValue = rainyCsarHelperMultiVfs.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), null);
 115                 assertNull(nodeTemplatePropertyLeafValue);
 116         }
 117
 118         @Test
 119         public void testNodeTemplateFlatPropertyByNullNodeTemplate() throws SdcToscaParserException {
 120                 String nodeTemplatePropertyLeafValue = rainyCsarHelperMultiVfs.getNodeTemplatePropertyLeafValue(null, "availability_zone_max_count");
 121                 assertNull(nodeTemplatePropertyLeafValue);
 122         }
 123         //endregion
 124
 125         //region getServiceVlList
 126         @Test
 127         public void testServiceVl() {
 128                 List<NodeTemplate> vlList = fdntCsarHelper.getServiceVlList();
 129                 assertEquals(1, vlList.size());
 130                 assertEquals("exVL", vlList.get(0).getName());
 131         }
 132
 133         @Test
 134         public void testNumberOfVLRainyFlow() throws SdcToscaParserException {
 135                 List<NodeTemplate> serviceVlList = rainyCsarHelperMultiVfs.getServiceVlList();
 136                 assertNotNull(serviceVlList);
 137                 assertEquals(0, serviceVlList.size());
 138         }
 139         //endregion
 140
 141         //region getServiceNodeTemplatesByType
 142         @Test
 143         public void testServiceNodeTemplatesByType() throws SdcToscaParserException {
 144                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceNodeTemplatesByType("org.openecomp.resource.vf.Fdnt");
 145                 assertNotNull(serviceVfList);
 146                 assertEquals(1, serviceVfList.size());
 147         }
 148
 149         @Test
 150         public void testServiceNodeTemplatesByNull() {
 151                 List<NodeTemplate> nodeTemplates = rainyCsarHelperMultiVfs.getServiceNodeTemplatesByType(null);
 152                 assertNotNull(nodeTemplates);
 153                 assertEquals(0, nodeTemplates.size());
 154         }
 155
 156         @Test
 157         public void testServiceNodeTemplatesByNotFoundProperty() {
 158                 List<NodeTemplate> nodeTemplates = rainyCsarHelperMultiVfs.getServiceNodeTemplatesByType("XXX");
 159                 assertNotNull(nodeTemplates);
 160                 assertEquals(0, nodeTemplates.size());
 161         }
 162         //endregion
 163
 164         //region getTypeOfNodeTemplate
 165         @Test
 166         public void testGetTypeOfNodeTemplate() {
 167                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
 168                 String typeOfNodeTemplate = fdntCsarHelper.getTypeOfNodeTemplate(serviceVfList.get(0));
 169                 assertEquals("org.openecomp.resource.vf.Fdnt", typeOfNodeTemplate);
 170         }
 171
 172         @Test
 173         public void testGetTypeOfNullNodeTemplate() {
 174                 String typeOfNodeTemplate = rainyCsarHelperMultiVfs.getTypeOfNodeTemplate(null);
 175                 assertNull(typeOfNodeTemplate);
 176         }
 177         //endregion
 178
 179         //region getAllottedResources
 180         @Test
 181         public void testGetAllottedResources() {
 182                 List<NodeTemplate> allottedResources = fdntCsarHelper.getAllottedResources();
 183                 assertEquals(1, allottedResources.size());
 184         }
 185
 186         @Test
 187         public void testGetAllottedResourcesZero() {
 188                 List<NodeTemplate> allottedResources = rainyCsarHelperMultiVfs.getAllottedResources();
 189                 assertNotNull(allottedResources);
 190                 assertEquals(0, allottedResources.size());
 191         }
 192         //endregion
 193
 194         //region getVfcListByVf
 195         @Test
 196         public void testGetVfcFromVf() {
 197                 List<NodeTemplate> vfcListByVf = fdntCsarHelper.getVfcListByVf(VF_CUSTOMIZATION_UUID);
 198                 assertEquals(2, vfcListByVf.size());
 199         }
 200
 201         @Test
 202         public void testVfcListByNull() {
 203                 List<NodeTemplate> vfcList = rainyCsarHelperMultiVfs.getVfcListByVf(null);
 204                 assertNotNull(vfcList);
 205                 assertEquals(0, vfcList.size());
 206         }
 207
 208         @Test
 209         public void testVfcListByNotFoundProperty() {
 210                 List<NodeTemplate> vfcList = rainyCsarHelperMultiVfs.getVfcListByVf("XXX");
 211                 assertNotNull(vfcList);
 212                 assertEquals(0, vfcList.size());
 213         }
 214         //endregion
 215
 216         //region getCpListByVf
 217         @Test
 218         public void testGetCpFromVf() {
 219                 List<NodeTemplate> cpListByVf = fdntCsarHelper.getCpListByVf(VF_CUSTOMIZATION_UUID);
 220                 assertEquals(1, cpListByVf.size());
 221                 NodeTemplate nodeTemplate = cpListByVf.get(0);
 222                 assertEquals("DNT_PORT", nodeTemplate.getName());
 223         }
 224
 225         @Test
 226         public void testGetCpFromVfByNullId() {
 227                 List<NodeTemplate> cpListByVf = rainyCsarHelperMultiVfs.getCpListByVf(null);
 228                 assertNotNull(cpListByVf);
 229                 assertEquals(0, cpListByVf.size());
 230         }
 231
 232         @Test
 233         public void testGetCpFromVfXxx() {
 234                 List<NodeTemplate> cpListByVf = rainyCsarHelperMultiVfs.getCpListByVf("XXXXX");
 235                 assertNotNull(cpListByVf);
 236                 assertEquals(0, cpListByVf.size());
 237         }
 238         //endregion
 239
 240         //region getNodeTemplatePairsByReqName
 241         @Test
 242         public void testGetNodeTemplatePairsByReqName() {
 243                 List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = fdntCsarHelper.getNodeTemplatePairsByReqName(fdntCsarHelper.getCpListByVf(VF_CUSTOMIZATION_UUID), fdntCsarHelper.getVfcListByVf(VF_CUSTOMIZATION_UUID), "binding");
 244                 assertNotNull(nodeTemplatePairsByReqName);
 245                 assertEquals(1, nodeTemplatePairsByReqName.size());
 246                 Pair<NodeTemplate, NodeTemplate> pair = nodeTemplatePairsByReqName.get(0);
 247                 NodeTemplate cp = pair.getLeft();
 248                 NodeTemplate vfc = pair.getRight();
 249                 assertEquals("DNT_PORT", cp.getName());
 250                 assertEquals("DNT_FW_RHRG", vfc.getName());
 251         }
 252
 253         @Test
 254         public void testGetNodeTemplatePairsByReqNameWithNullVF() {
 255                 List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = fdntCsarHelper.getNodeTemplatePairsByReqName(
 256                                 null, fdntCsarHelper.getVfcListByVf(VF_CUSTOMIZATION_UUID), "binding");
 257                 assertNotNull(nodeTemplatePairsByReqName);
 258                 assertEquals(0, nodeTemplatePairsByReqName.size());
 259         }
 260
 261         @Test
 262         public void testGetNodeTemplatePairsByReqNameWithEmptyVF() {
 263                 List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = fdntCsarHelper.getNodeTemplatePairsByReqName(
 264                                 new ArrayList<>(), fdntCsarHelper.getVfcListByVf(VF_CUSTOMIZATION_UUID), "binding");
 265                 assertNotNull(nodeTemplatePairsByReqName);
 266                 assertEquals(0, nodeTemplatePairsByReqName.size());
 267         }
 268
 269         @Test
 270         public void testGetNodeTemplatePairsByReqNameWithNullCap() {
 271                 List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = fdntCsarHelper.getNodeTemplatePairsByReqName(
 272                                 fdntCsarHelper.getCpListByVf(VF_CUSTOMIZATION_UUID), null, "binding");
 273                 assertNotNull(nodeTemplatePairsByReqName);
 274                 assertEquals(0, nodeTemplatePairsByReqName.size());
 275         }
 276
 277         @Test
 278         public void testGetNodeTemplatePairsByReqNameWithEmptyCap() {
 279                 List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = fdntCsarHelper.getNodeTemplatePairsByReqName(
 280                                 fdntCsarHelper.getCpListByVf(VF_CUSTOMIZATION_UUID), new ArrayList<>(), "binding");
 281                 assertNotNull(nodeTemplatePairsByReqName);
 282                 assertEquals(0, nodeTemplatePairsByReqName.size());
 283         }
 284
 285         @Test
 286         public void testGetNodeTemplatePairsByReqNameWithNullReq() {
 287                 List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = fdntCsarHelper.getNodeTemplatePairsByReqName(
 288                                 fdntCsarHelper.getCpListByVf(VF_CUSTOMIZATION_UUID), fdntCsarHelper.getVfcListByVf(VF_CUSTOMIZATION_UUID), null);
 289                 assertNotNull(nodeTemplatePairsByReqName);
 290                 assertEquals(0, nodeTemplatePairsByReqName.size());
 291         }
 292
 293         @Test
 294         public void testGetNodeTemplatePairsByReqNameWithDummyReq() {
 295
 296                 List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = fdntCsarHelper.getNodeTemplatePairsByReqName(
 297                                 fdntCsarHelper.getCpListByVf(VF_CUSTOMIZATION_UUID), fdntCsarHelper.getVfcListByVf(VF_CUSTOMIZATION_UUID), "XXX");
 298                 assertNotNull(nodeTemplatePairsByReqName);
 299                 assertEquals(0, nodeTemplatePairsByReqName.size());
 300         }
 301         //endregion
 302
 303         //region getMembersOfVfModule
 304         @Test
 305         public void testGetMembersOfVfModule() {
 306                 NodeTemplate vf = fdntCsarHelper.getServiceVfList().get(0);
 307                 List<Group> vfModulesByVf = fdntCsarHelper.getVfModulesByVf(VF_CUSTOMIZATION_UUID);
 308                 assertEquals(2, vfModulesByVf.size());
 309                 for (Group group : vfModulesByVf) {
 310                         List<NodeTemplate> membersOfVfModule = fdntCsarHelper.getMembersOfVfModule(vf, group);
 311                         assertNotNull(membersOfVfModule);
 312                         if (group.getName().equals("fdnt1..Fdnt..base_stsi_dnt_frwl..module-0")) {
 313                                 assertEquals(1, membersOfVfModule.size());
 314                                 NodeTemplate nodeTemplate = membersOfVfModule.get(0);
 315                                 assertEquals("DNT_FW_RSG_SI_1", nodeTemplate.getName());
 316                         } else {
 317                                 assertEquals("fdnt1..Fdnt..mod_vmsi_dnt_fw_parent..module-1", group.getName());
 318                                 assertEquals(1, membersOfVfModule.size());
 319                                 NodeTemplate nodeTemplate = membersOfVfModule.get(0);
 320                                 assertEquals("DNT_FW_RHRG", nodeTemplate.getName());
 321                         }
 322                 }
 323         }
 324
 325         @Test
 326         public void testMembersOfVfModuleByNullVf() {
 327                 List<Group> vfModulesByVf = fdntCsarHelper.getVfModulesByVf(VF_CUSTOMIZATION_UUID);
 328                 List<NodeTemplate> nodeTemplates = fdntCsarHelper.getMembersOfVfModule(null, vfModulesByVf.get(0));
 329                 assertNotNull(nodeTemplates);
 330                 assertEquals(0, nodeTemplates.size());
 331         }
 332
 333         @Test
 334         public void testMembersOfVfModuleByNullGroup() {
 335                 List<NodeTemplate> serviceVfList = rainyCsarHelperMultiVfs.getServiceVfList();
 336                 List<NodeTemplate> nodeTemplates = rainyCsarHelperMultiVfs.getMembersOfVfModule(serviceVfList.get(0), null);
 337                 assertNotNull(nodeTemplates);
 338                 assertEquals(0, nodeTemplates.size());
 339         }
 340         //endregion
 341
 342         //region getCpPropertiesFromVfc
 343         @SuppressWarnings("unchecked")
 344         @Test
 345         public void testGetCpPropertiesFromVfc() {
 346                 List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 347                 boolean isChecked = false;
 348
 349                 for (NodeTemplate vfc: vfcs) {
 350
 351                         if(vfc.getName().equalsIgnoreCase("abstract_pd_server"))
 352                         {
 353                                 isChecked = true;
 354                                 Map<String, Map<String, Object>> cps = ipAssignCsarHelper.getCpPropertiesFromVfcAsObject(vfc);
 355
 356                                 assertEquals(2,cps.size());
 357                                 Map<String, Object> pd01 = cps.get("port_pd01_port");
 358                                 assertEquals(5, pd01.size());
 359
 360                                 Map<String, Object> firstIpRequirements = (Map<String, Object>) ((List<Object>)pd01.get("ip_requirements")).get(0);
 361                                 Map<String, Object> secondIpRequirements = (Map<String, Object>) ((List<Object>)pd01.get("ip_requirements")).get(1);
 362
 363                                 assertEquals("subnet_role_4", firstIpRequirements.get("subnet_role"));
 364                                 assertEquals(4, firstIpRequirements.get("ip_version"));
 365                                 assertEquals(true, ((Map<String, Object>) firstIpRequirements.get("ip_count_required")).get("is_required"));
 366                                 assertEquals("get_input:node_count", ((Map<String, Object>) firstIpRequirements.get("ip_count_required")).get("count").toString());
 367                                 assertEquals(false, ((Map<String, Object>)((Map<String, Object>)pd01.get("mac_requirements")).get("mac_count_required")).get("is_required"));
 368                                 assertEquals("test_subnetpoolid", pd01.get("subnetpoolid"));
 369                                 assertEquals("oam", pd01.get("network_role_tag"));
 370                                 assertEquals(6, secondIpRequirements.get("ip_version"));
 371                         }
 372
 373                 }
 374                 assertTrue(isChecked);
 375         }
 376
 377         @Test
 378         public void testGetCpPropertiesFromVfcForNullVFC() {
 379                 Map<String, Map<String, Object>> cps = ipAssignCsarHelper.getCpPropertiesFromVfcAsObject(null);
 380                 assertNotNull(cps);
 381                 assertEquals(0, cps.size());
 382         }
 383         //endregion
 384
 385         //region getNodeTemplatePropertyAsObject
 386         @Test
 387         public void testGetNodeTemplatePropertyAsObject() {
 388                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
 389                 assertEquals("2", fdntCsarHelper.getNodeTemplatePropertyAsObject(serviceVfList.get(0), "availability_zone_max_count"));
 390                 assertEquals(3, fdntCsarHelper.getNodeTemplatePropertyAsObject(serviceVfList.get(0), "max_instances"));
 391                 assertEquals("some code", fdntCsarHelper.getNodeTemplatePropertyAsObject(serviceVfList.get(0), "nf_naming_code"));
 392         }
 393         //endregion
 394
 395         //region getServiceNodeTemplates
 396         @Test
 397         public void testServiceNodeTemplates() throws SdcToscaParserException {
 398                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceNodeTemplates();
 399                 assertNotNull(serviceVfList);
 400                 assertEquals(3, serviceVfList.size());
 401                 assertEquals(serviceVfList.get(2).getName(), "exVL");
 402         }
 403         //endregion
 404
 405     //region filterNodeTemplatePropertiesByValue
 406     @Test
 407     public void testFilterNodeTemplatePropertiesByContains() {
 408         List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 409         boolean isChecked = false;
 410         for (NodeTemplate vfc: vfcs) {
 411             if(vfc.getName().equalsIgnoreCase("abstract_pd_server"))
 412             {
 413                 isChecked = true;
 414                 Map<String, String> filteredInputs = ipAssignCsarHelper.filterNodeTemplatePropertiesByValue(vfc, FilterType.CONTAINS, "get_input");
 415
 416                 assertEquals(7, filteredInputs.size());
 417                 assertEquals("get_input:availabilityzone_name", filteredInputs.get("compute_pd_server_availability_zone"));
 418                                 assertEquals("get_input:[pd_server_names, 0]", filteredInputs.get("compute_pd_server_name"));
 419                                 assertEquals("get_input:node_count", filteredInputs.get("port_pd01_port_ip_requirements#ip_count_required#count"));
 420
 421                 break;
 422             }
 423
 424         }
 425         assertTrue(isChecked);
 426     }
 427
 428     @Test
 429     public void testFilterNodeTemplatePropertiesByDummyContains() {
 430         List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 431         Map<String, String> filteredInputs = ipAssignCsarHelper.filterNodeTemplatePropertiesByValue(vfcs.get(0), FilterType.CONTAINS, "dummy");
 432         assertNotNull(filteredInputs);
 433         assertEquals(0, filteredInputs.size());
 434     }
 435
 436     @Test
 437     public void testFilterNodeTemplatePropertiesByEquals() {
 438         List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 439         boolean isChecked = false;
 440         for (NodeTemplate vfc: vfcs) {
 441             if(vfc.getName().equalsIgnoreCase("abstract_pd_server"))
 442             {
 443                 isChecked = true;
 444                 Map<String, String> filteredInputs = ipAssignCsarHelper.filterNodeTemplatePropertiesByValue(vfc, FilterType.EQUALS, "oam");
 445
 446                 assertEquals(2, filteredInputs.size());
 447                 assertEquals("oam", filteredInputs.get("port_pd02_port_network_role_tag"));
 448                 assertEquals("oam", filteredInputs.get("port_pd01_port_network_role_tag"));
 449                 break;
 450             }
 451
 452         }
 453         assertTrue(isChecked);
 454     }
 455
 456         @Test
 457         public void testFilterNodeTemplatePropertiesByDummyEquals() {
 458                 List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 459                 Map<String, String> filteredInputs = ipAssignCsarHelper.filterNodeTemplatePropertiesByValue(vfcs.get(0), FilterType.EQUALS, "dummy");
 460                 assertNotNull(filteredInputs);
 461                 assertEquals(0, filteredInputs.size());
 462         }
 463
 464         @Test
 465         public void testFilterNodeTemplatePropertiesByNullFilterType() {
 466                 List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 467                 Map<String, String> filteredInputs = ipAssignCsarHelper.filterNodeTemplatePropertiesByValue(vfcs.get(0), null, "ddc");
 468                 assertNotNull(filteredInputs);
 469                 assertEquals(0, filteredInputs.size());
 470         }
 471
 472         @Test
 473         public void testFilterNodeTemplatePropertiesByNullPattern() {
 474                 List<NodeTemplate> vfcs = ipAssignCsarHelper.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 475                 Map<String, String> filteredInputs = ipAssignCsarHelper.filterNodeTemplatePropertiesByValue(vfcs.get(0), FilterType.EQUALS, null);
 476                 assertNotNull(filteredInputs);
 477                 assertEquals(0, filteredInputs.size());
 478         }
 479
 480         @Test
 481         public void testFilterNodeTemplatePropertiesByNullVfc() {
 482                 Map<String, String> filteredInputs = ipAssignCsarHelper.filterNodeTemplatePropertiesByValue(null, FilterType.EQUALS, "ddc");
 483                 assertNotNull(filteredInputs);
 484                 assertEquals(0, filteredInputs.size());
 485         }
 486         //endregion
 487
 488         //region getServiceNodeTemplateBySdcType
 489         @Test
 490         public void testServiceNodeTemplateBySdcType() {
 491                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceNodeTemplateBySdcType(SdcTypes.VF);
 492                 assertNotNull(serviceVfList);
 493                 assertEquals(serviceVfList.size(), 2);
 494                 assertEquals(serviceVfList.get(0).getName(), "FDNT 1");
 495         }
 496
 497         @Test
 498         public void testServiceNodeTemplateBySdcTypeServiceProxy() {
 499                 List<NodeTemplate> serviceProxies = portMirroring.getServiceNodeTemplateBySdcType(SdcTypes.SERVICE_PROXY);
 500                 assertNotNull(serviceProxies);
 501                 assertEquals(serviceProxies.size(), 2);
 502         }
 503
 504         @Test
 505         public void testServiceNodeTemplateByNullSdcType() {
 506                 List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceNodeTemplateBySdcType(null);
 507                 assertNotNull(serviceVfList);
 508                 assertEquals(serviceVfList.size(), 0);
 509         }
 510         //endregion
 511
 512         //region getNodeTemplateBySdcType
 513         @Test
 514         public void testNodeTemplateBySdcType() {
 515                 List<NodeTemplate> vfList = fdntCsarHelper.getServiceVfList();
 516                 List<NodeTemplate> vfcList = fdntCsarHelper.getNodeTemplateBySdcType(vfList.get(0), SdcTypes.VFC);
 517                 assertNotNull(vfcList);
 518                 assertEquals(2, vfcList.size());
 519                 assertEquals("DNT_FW_RSG_SI_1", vfcList.get(0).getName());
 520         }
 521
 522         @Test
 523         public void testNodeTemplateByNullSdcType() {
 524                 List<NodeTemplate> vfList = fdntCsarHelper.getServiceVfList();
 525                 List<NodeTemplate> vfcList = fdntCsarHelper.getNodeTemplateBySdcType(vfList.get(0), null);
 526                 assertNotNull(vfcList);
 527                 assertEquals(0, vfcList.size());
 528         }
 529
 530         @Test
 531         public void testNodeTemplateBySdcTypeNullNT() {
 532                 List<NodeTemplate> vfcList = fdntCsarHelper.getNodeTemplateBySdcType(null, SdcTypes.VFC);
 533                 assertNotNull(vfcList);
 534                 assertEquals(0, vfcList.size());
 535         }
 536         //endregion
 537
 538         //region getVnfConfig
 539     @Test
 540     public void testGetVnfConfig() {
 541         NodeTemplate vnfConfig = nfodCsarHlper.getVnfConfig("9bb2ef82-f8f6-4391-bc71-db063f15bf57");
 542         assertNotNull(vnfConfig);
 543         assertEquals("vnfConfiguration", vnfConfig.getMetaData().getValue("name"));
 544     }
 545
 546     @Test
 547     public void testGetVnfConfigByNonFoundVNF() {
 548         NodeTemplate vnfConfig = ipAssignCsarHelper.getVnfConfig("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 549         assertNull(vnfConfig);
 550     }
 551
 552     @Test
 553     public void testGetVnfConfigByDummyUUID() {
 554         NodeTemplate vnfConfig = nfodCsarHlper.getVnfConfig("XXX");
 555         assertNull(vnfConfig);
 556     }
 557
 558     @Test
 559     public void testGetVnfConfigByNullUUID() {
 560         NodeTemplate vnfConfig = nfodCsarHlper.getVnfConfig(null);
 561         assertNull(vnfConfig);
 562     }
 563
 564     @Test
 565     public void testGetVfcTypWithoutVnf() {
 566         List<NodeTemplate> vfcList = nfodCsarHlper.getVfcListByVf("9bb2ef82-f8f6-4391-bc71-db063f15bf57");
 567         assertNotNull(vfcList);
 568         assertEquals(2, vfcList.size());
 569     }
 570     //endregion
 571
 572         //region nested vfc
 573         @Test
 574         public void testNestedVfcByExistCvfc() {
 575                 List<NodeTemplate> vfcList = nestedVfcCsarHlper.getVfcListByVf("71389f8b-8671-4a43-a991-59fb621d3615");
 576                 assertNotNull(vfcList);
 577                 assertEquals(vfcList.size(), 2);
 578                 assertEquals("VFC1 DUMMY", vfcList.get(0).getName());
 579                 assertEquals("VF_VNF", vfcList.get(1).getName());
 580         }
 581
 582         @Test
 583         public void testNestedVfcByNullVf() {
 584                 List<NodeTemplate> vfcList = nestedVfcCsarHlper.getVfcListByVf(null);
 585                 assertNotNull(vfcList);
 586                 assertEquals(0, vfcList.size());
 587         }
 588
 589         @Test
 590         public void testNestedVfcByDummyVf() {
 591                 List<NodeTemplate> vfcList = nestedVfcCsarHlper.getVfcListByVf("dummy");
 592                 assertNotNull(vfcList);
 593                 assertEquals(0, vfcList.size());
 594         }
 595         //endregion
 596
 597         //region hasTopology
 598         @Test
 599         public void testHasTopologyByVF() {
 600                 List<NodeTemplate> vfList = nestedVfcCsarHlper.getServiceVfList();
 601                 boolean hasTopology = nestedVfcCsarHlper.hasTopology(vfList.get(0));
 602                 assertEquals(true, hasTopology);
 603         }
 604
 605         @Test
 606         public void testHasTopologyByCVFC() {
 607                 List<NodeTemplate> vfcList = nestedVfcCsarHlper.getVfcListByVf("71389f8b-8671-4a43-a991-59fb621d3615");
 608                 boolean hasTopology = nestedVfcCsarHlper.hasTopology(vfcList.get(1));
 609                 assertEquals(true, hasTopology);
 610         }
 611
 612         @Test
 613         public void testHasTopologyByVL() {
 614                 List<NodeTemplate> serviceVlList = fdntCsarHelper.getServiceVlList();
 615                 boolean hasTopology = fdntCsarHelper.hasTopology(serviceVlList.get(0));
 616                 assertEquals(false, hasTopology);
 617         }
 618
 619         @Test
 620         public void testHasTopologyByNull() {
 621                 boolean hasTopology = fdntCsarHelper.hasTopology(null);
 622                 assertEquals(false, hasTopology);
 623         }
 624         //endregion
 625
 626         //region getNodeTemplateChildren
 627         @Test
 628         public void testGetNodeTemplatesListOfNodeTemplateByVF() {
 629                 List<NodeTemplate> vfList = fdntCsarHelper.getServiceVfList();
 630                 List<NodeTemplate> children = fdntCsarHelper.getNodeTemplateChildren(vfList.get(0));
 631                 assertNotNull(children);
 632                 assertEquals(3, children.size());
 633
 634                 children.sort(Comparator.comparing(NodeTemplate::getName));
 635
 636                 assertEquals("DNT_FW_RSG_SI_1", children.get(1).getName());
 637                 assertEquals("VFC", children.get(1).getMetaData().getValue("type"));
 638                 assertEquals("DNT_PORT", children.get(2).getName());
 639                 assertEquals("CP", children.get(2).getMetaData().getValue("type"));
 640         }
 641
 642         @Test
 643         public void testGetNodeTemplatesListOfNodeTemplateByVFC() {
 644                 List<NodeTemplate> vfList = nestedVfcCsarHlper.getServiceVfList();
 645                 List<NodeTemplate> vfChildren = nestedVfcCsarHlper.getNodeTemplateChildren(vfList.get(0));
 646                 assertNotNull(vfChildren);
 647                 assertEquals(vfChildren.size(), 2);
 648                 vfChildren.sort(Comparator.comparing(NodeTemplate::getName));
 649                 assertEquals("VFC1 DUMMY", vfChildren.get(0).getName());
 650                 assertEquals("VF_VNF", vfChildren.get(1).getName());
 651                 assertEquals("CVFC", vfChildren.get(1).getMetaData().getValue("type"));
 652
 653
 654                 List<NodeTemplate> vfcChildren = nestedVfcCsarHlper.getNodeTemplateChildren(vfChildren.get(1));
 655                 assertNotNull(vfcChildren);
 656                 assertEquals(vfcChildren.size(), 3);
 657                 vfcChildren.sort(Comparator.comparing(NodeTemplate::getName));
 658                 assertEquals("Test NIC 02_wan_port", vfcChildren.get(0).getName());
 659                 assertEquals("Test NIC_wan_port", vfcChildren.get(1).getName());
 660                 assertEquals("VF", vfcChildren.get(2).getName());
 661         }
 662
 663         @Test
 664         public void testGetNodeTemplatesListOfNodeTemplateByNull() {
 665                 List<NodeTemplate> children = fdntCsarHelper.getNodeTemplateChildren(null);
 666                 assertNotNull(children);
 667                 assertEquals(0, children.size());
 668         }
 669         //endregion
 670
 671     // added by QA
 672     // Get specific VNF properties
 673     @Test
 674     public void testGetVnfConfigGetProperties() {
 675         NodeTemplate vnfConfig = nfodCsarHlper.getVnfConfig("9bb2ef82-f8f6-4391-bc71-db063f15bf57");
 676         assertNotNull(vnfConfig);
 677         assertEquals("vnfConfiguration", vnfConfig.getMetaData().getValue("name"));
 678
 679         String manufacturer_reference_number = nfodCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#ATT_part_12345_for_FortiGate-VM00#vendor_info#manufacturer_reference_number");
 680         String num_cpus = nfodCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#ATT_part_67890_for_FortiGate-VM01#compute_flavor#num_cpus");
 681         String sp_part_number = nfodCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#ATT_part_67890_for_FortiGate-VM01#sp_part_number");
 682
 683         assertEquals("FortiGate-VM00",manufacturer_reference_number);
 684         assertEquals("10",num_cpus);
 685         assertEquals("ATT_part_67890_for_FortiGate-VM01",sp_part_number);
 686     }
 687
 688     // added by QA
 689     // Check that get vnfconfiguration not return as VFC
 690     @Test
 691     public void testGetVfcTypWithoutVnfCheckNames() {
 692         List<NodeTemplate> vfcList = nfodCsarHlper.getVfcListByVf("9bb2ef82-f8f6-4391-bc71-db063f15bf57");
 693         assertNotNull(vfcList);
 694         assertEquals(2, vfcList.size());
 695         for (int i = 0; i < vfcList.size(); i++) {
 696
 697                 String Name= vfcList.get(i).getName();
 698
 699                 assertEquals(false, Name.equals("vFW_VNF_Configuration"));
 700
 701                 }
 702     }
 703
 704     @Test
 705     public void testNewGetVnfConfigGetProperties() {
 706         NodeTemplate vnfConfig = nfodNEWCsarHlper.getVnfConfig("a6587663-b27f-4e88-8a86-604604302ce6");
 707         assertNotNull(vnfConfig);
 708         assertEquals("vnfConfiguration", vnfConfig.getMetaData().getValue("name"));
 709
 710         //Deployment flavor 1
 711         String manufacturer_reference_number = nfodNEWCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#123456#vendor_info#manufacturer_reference_number");
 712         String num_cpus = nfodNEWCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#123456#compute_flavor#num_cpus");
 713         String sp_part_number = nfodNEWCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#123456#sp_part_number");
 714
 715         assertEquals("234567",manufacturer_reference_number);
 716         assertEquals("2",num_cpus);
 717         assertEquals("123456",sp_part_number);
 718
 719         //Deployment flavor 2
 720         manufacturer_reference_number = nfodNEWCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#FG_partNumbereJqQjUkteF1#vendor_info#manufacturer_reference_number");
 721         num_cpus = nfodNEWCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#FG_partNumbereJqQjUkteF1#compute_flavor#num_cpus");
 722         sp_part_number = nfodNEWCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#FG_partNumbereJqQjUkteF1#sp_part_number");
 723
 724         assertEquals("EP_manufacturerReferenceNumberkbAiqZZNzx1",manufacturer_reference_number);
 725         assertEquals("1",num_cpus);
 726         assertEquals("FG_partNumbereJqQjUkteF1",sp_part_number);
 727     }
 728
 729     // added by QA
 730     // Check that get vnfconfiguration not return as VFC
 731     @Test
 732     public void testNewGetVfcTypWithoutVnfCheckNames() {
 733         List<NodeTemplate> vfcList = nfodNEWCsarHlper.getVfcListByVf("a6587663-b27f-4e88-8a86-604604302ce6");
 734         assertNotNull(vfcList);
 735         assertEquals(1, vfcList.size());
 736         for (int i = 0; i < vfcList.size(); i++) {
 737
 738                 String Name= vfcList.get(i).getName();
 739
 740                 assertEquals(false, Name.equals("name_6GkVrOjnGp1_VNF_Configuration"));
 741                 }
 742     }
 743
 744     //region getServiceNodeTemplateByNodeName
 745         @Test
 746         public void testGetServiceNodeTemplateByRealNodeName() {
 747                 NodeTemplate nodeTemplate = fdntCsarHelper.getServiceNodeTemplateByNodeName("FDNT 1");
 748                 assertNotNull(nodeTemplate);
 749                 assertEquals(nodeTemplate.getName(), "FDNT 1");
 750                 assertEquals(nodeTemplate.getMetaData().getValue("type"), "VF");
 751         }
 752
 753         @Test
 754         public void testGetServiceNodeTemplateByNullNodeName() {
 755                 NodeTemplate nodeTemplate = fdntCsarHelper.getServiceNodeTemplateByNodeName(null);
 756                 assertNull(nodeTemplate);
 757         }
 758
 759         @Test
 760         public void testGetServiceNodeTemplateByDummyNodeName() {
 761                 NodeTemplate nodeTemplate = fdntCsarHelper.getServiceNodeTemplateByNodeName("dummy");
 762                 assertNull(nodeTemplate);
 763         }
 764
 765
 766
 767         //endregion
 768         //region resolve get_input
 769         @SuppressWarnings("rawtypes")
 770         @Test
 771         public void testResolveGetInputForComplexTypeAndList() {
 772                 //port_pd01_port_ip_requirements is of type list<org.openecomp.datatypes.network.IpRequirements>
 773                 //This test covers:
 774                 // 1) "default" resolving
 775                 // 2) complex type resolving
 776                 // 3) List access resolving
 777                 List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 778                 Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
 779                 assertTrue(propertyAsObject instanceof ArrayList);
 780                 assertEquals(2, ((ArrayList) propertyAsObject).size());
 781                 //port_pd01_port_ip_requirements:
 782                 //- get_input: [ip_requirements, 0]
 783                 //- get_input: [ip_requirements, 1]
 784                 assertEquals("subnet_role_4", ((Map) ((ArrayList) propertyAsObject).get(0)).get("subnet_role"));
 785                 assertEquals("subnet_role_6", ((Map) ((ArrayList) propertyAsObject).get(1)).get("subnet_role"));
 786         }
 787
 788         @Test
 789         public void testResolveGetInputForListOnNetworkCloud() {
 790                 final String related_network_role = "related_network_role";
 791                 List<NodeTemplate> serviceVfList = csarHelperServiceNetworkCloud.getServiceVfList();
 792                 assertNotNull(serviceVfList);
 793                 assertFalse(serviceVfList.isEmpty());
 794                 List<NodeTemplate> vfcListByVf = csarHelperServiceNetworkCloud.getVfcListByVf(csarHelperServiceNetworkCloud.getNodeTemplateCustomizationUuid(serviceVfList.get(0)));
 795                 assertNotNull(vfcListByVf);
 796                 assertFalse(vfcListByVf.isEmpty());
 797                 List<NodeTemplate> cpList = csarHelperServiceNetworkCloud.getNodeTemplateChildren(vfcListByVf.get(0));
 798                 assertNotNull(cpList);
 799                 assertFalse(cpList.isEmpty());
 800                 final Object propertyValue = cpList.get(0).getPropertyValue("related_networks");
 801                 assertNotNull(propertyValue);
 802                 ArrayList<Map<String, String>> relatedNetworkList = (ArrayList)propertyValue;
 803                 assertEquals(3, relatedNetworkList.size());
 804                 assertEquals("cor_direct_2", relatedNetworkList.get(0).get(related_network_role));
 805                 assertEquals("sgi_direct_2", relatedNetworkList.get(1).get(related_network_role));
 806                 assertEquals("int_imbl_2", relatedNetworkList.get(2).get(related_network_role));
 807         }
 808
 809         @Test
 810         public void testResolveGetInputForPrimitiveTypeString() {
 811                 //This test covers "default" resolving of primitive - as Object
 812                 List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 813                 Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_network_role_tag");
 814                 assertEquals("oam", propertyAsObject);
 815         }
 816
 817         @Test
 818         public void testResolveGetInputForPrimitiveTypeInteger() {
 819                 //This test covers "default" resolving of primitive - as String
 820                 List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 821                 String propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyLeafValue(vfcs.get(0), "port_pd01_port_order");
 822                 assertEquals("1", propertyAsObject);
 823         }
 824
 825         @SuppressWarnings("rawtypes")
 826         @Test
 827         public void testResolveGetInputForMap() {
 828                 //This test covers "default" resolving of primitive - as Map
 829                 List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 830                 Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd02_port_ip_requirements#ip_count_required");
 831                 assertTrue(propertyAsObject instanceof Map);
 832                 assertEquals(false, ((Map)propertyAsObject).get("is_required"));
 833         }
 834
 835         @Test
 836         public void testResolveGetInputForAllHierarchy() {
 837                 //This test covers "default" resolving from service level
 838                 List<NodeTemplate> vfs = resolveGetInputCsar.getServiceVfList();
 839                 Object vfPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfs.get(0), "vm_count");
 840                 assertEquals(2, vfPropertyAsObject);
 841                 //This test covers property assignment resolving on VFI level (service template), from Vf level
 842                 List<NodeTemplate> vfcs = resolveGetInputCsar.getNodeTemplateBySdcType(vfs.get(0), SdcTypes.VFC);
 843                 Object vfcPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "my_count");
 844                 assertEquals(2, vfcPropertyAsObject); //takes it from upper level (VF) property
 845         }
 846
 847         @Test
 848         public void testResolveGetInputNoDefValueInnerLevel() {
 849                 //This test covers resolving when no "default" value is supplied to the input - should be null - VF/VFCI level
 850                 List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 851                 String propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyLeafValue(vfcs.get(0), "index_value");
 852                 assertNull(propertyAsObject);
 853
 854         }
 855
 856         @Test
 857         public void testResolveGetInputNoDefValueServiceLevel() {
 858                 //This test covers resolving when no "default" value is supplied to the input - should be null - Service/VFI level
 859                 List<NodeTemplate> vfs = resolveGetInputCsar.getServiceVfList();
 860                 Object vfPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfs.get(0), "port_order");
 861                 assertNull(vfPropertyAsObject);
 862
 863         }
 864         //endregion
 865
 866         // region Added by QA - Continue with testings of resolve get_input
 867
 868         @SuppressWarnings("rawtypes")
 869         @Test
 870         public void testResolveGetInputForComplexTypeAndListWithFalseValue()
 871         {
 872                 List<NodeTemplate> vfcs = resolveGetInputCsarFalse.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 873                 Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
 874                 assertTrue(propertyAsObject instanceof ArrayList);
 875                 assertEquals(2, ((ArrayList) propertyAsObject).size());
 876                 assertEquals("get_input:[ip_requirements, 0]", ((ArrayList) propertyAsObject).get(0).toString());
 877                 assertEquals("get_input:[ip_requirements, 1]", ((ArrayList) propertyAsObject).get(1).toString());
 878         }
 879
 880         @Test
 881         public void testResolveGetInputForPrimitiveTypeStringWithFalseValue() {
 882                 List<NodeTemplate> vfcs = resolveGetInputCsarFalse.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 883                 Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_network_role_tag");
 884                 assertEquals("get_input:role_tag_oam", propertyAsObject.toString());
 885         }
 886
 887         @Test
 888         public void testResolveGetInputForPrimitiveTypeListWithFalseValue() {
 889                 List<NodeTemplate> vfcs = resolveGetInputCsarFalse.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 890                 Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_name");
 891                 assertEquals("[get_input:[pd_server_names, 0]]", propertyAsObject.toString());
 892         }
 893
 894         //@Test // Maybe a bug here.... need to check with Esti - Mait was sent.
 895         public void testResolveGetInputForPrimitiveTypeList() {
 896                 List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 897                 Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_name");
 898                 assertEquals("\"ZRDM1MOGX01MPD001\"", propertyAsObject.toString());
 899         }
 900
 901         @Test
 902         public void testResolveGetInputForPrimitiveNullValue() {
 903                 List<NodeTemplate> vfcs = resolveGetInputCsarQA.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 904                 @SuppressWarnings("unchecked")
 905                 List<String>propertyAsObject = (List<String>) resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_availability_zone");
 906                 assertNull(propertyAsObject.get(0));
 907                 }
 908         @Test
 909         public void testResolveGetInputForPrimitiveIPValue() {
 910                 List<NodeTemplate> vfcs = resolveGetInputCsarQA.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 911                 Object propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "vm_image_name");
 912                 assertEquals("107.239.36.5", propertyAsObject.toString());
 913         }
 914
 915         //QA region getServiceNodeTemplateByNodeName tests
 916
 917         @Test
 918         public void getServiceNodeTemplateByNodeNameTypeVF() {
 919                 NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("VF_1_V_port_1 0");
 920                 assertNotNull(nodeTemplate);
 921                 assertEquals(nodeTemplate.getName(), "VF_1_V_port_1 0");
 922                 assertEquals(nodeTemplate.getMetaData().getValue("type"), "VF");
 923         }
 924
 925         @Test
 926         public void getServiceNodeTemplateByNodeNameTypeVL() {
 927                 NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("ExtVL 0");
 928                 assertNotNull(nodeTemplate);
 929                 assertEquals(nodeTemplate.getName(), "ExtVL 0");
 930                 assertEquals(nodeTemplate.getMetaData().getValue("type"), "VL");
 931         }
 932
 933         @Test
 934         public void getServiceNodeTemplateByNodeNameTypeCP() {
 935                 NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("ExtCP 0");
 936                 assertNotNull(nodeTemplate);
 937                 assertEquals(nodeTemplate.getName(), "ExtCP 0");
 938                 assertEquals(nodeTemplate.getMetaData().getValue("type"), "CP");
 939         }
 940
 941         @Test
 942         public void getServiceNodeTemplateByNodeNameTypePNF() {
 943                 NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("PNF TEST 0");
 944                 assertNotNull(nodeTemplate);
 945                 assertEquals(nodeTemplate.getName(), "PNF TEST 0");
 946                 assertEquals(nodeTemplate.getMetaData().getValue("type"), "PNF");
 947         }
 948
 949         //QA region  getServiceNodeTemplateBySdcType tests
 950
 951         @Test
 952         public void getServiceNodeTemplateBySdcType_VF() {
 953                 List<NodeTemplate> vfList = QAServiceForToscaParserTests.getServiceNodeTemplatesByType("org.openecomp.resource.vf.Vf1VPort1");
 954                 assertEquals(2, vfList.size());
 955                 assertEquals("VF_1_V_port_1", vfList.get(0).getMetaData().getValue("name"));
 956         }
 957         // endregion Added by QA - Continue with testings of resolve get_input
 958
 959
 960         @SuppressWarnings("rawtypes")
 961         @Test
 962         public void testResolveGetInputArrayStructure() {
 963                 List<NodeTemplate> vfcs = resolveGetInputCsarQA.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
 964                 Object propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_name");
 965                 assertEquals( ((ArrayList)propertyAsObject).get(0).toString(), "\"ZRDM1MOGX01MPD001\"");
 966                 propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
 967                 assertEquals( ((ArrayList)propertyAsObject).get(1), null);
 968         }
 969
 970         @Test
 971         public void testServiceNodeTemplateByCRType() {
 972                 List<NodeTemplate> serviceCRList = csarHelperServiceWithCrs.getServiceNodeTemplateBySdcType(SdcTypes.CR);
 973                 assertNotNull(serviceCRList);
 974                 assertEquals(serviceCRList.size(), 2);
 975                 assertEquals(serviceCRList.get(0).getName(), "chaya best cr 1");
 976                 assertEquals(serviceCRList.get(0).getType(), "org.openecomp.resource.cr.ChayaBestCr");
 977                 assertEquals(serviceCRList.get(1).getName(), "chaya best cr 0");
 978                 assertEquals(serviceCRList.get(1).getType(), "org.openecomp.resource.cr.ChayaBestCr");
 979         }
 980
 981         @Test
 982         public void testGetCPOfCRNodeTemplate() {
 983                 NodeTemplate nodeTemplate = csarHelperServiceWithCrs.getServiceNodeTemplateByNodeName("chaya best cr 0");
 984                 List<NodeTemplate> crCpChildren = csarHelperServiceWithCrs.getNodeTemplateBySdcType(nodeTemplate, SdcTypes.CP);
 985                 assertEquals(crCpChildren.get(0).getName(), "ContrailPort 0");
 986                 assertEquals(crCpChildren.get(0).getMetaData().getValue("type"), SdcTypes.CP.name());
 987         }
 988
 989         @Test
 990         public void testServiceCRInstanceProps() {
 991                 List<NodeTemplate> serviceCrList = csarHelperServiceWithCrs.getServiceNodeTemplateBySdcType(SdcTypes.CR);
 992                 assertNotNull(serviceCrList);
 993                 NodeTemplate crTemplate = serviceCrList.get(0);
 994                 assertNotNull(crTemplate);
 995                 assertEquals(crTemplate.getPropertyValue("nf_naming").toString(), ImmutableMap.of("ecomp_generated_naming", "true").toString());
 996                 assertEquals(crTemplate.getPropertyValue("contrailport0_virtual_network"), "chaya");
 997         }
 998
 999         @Test
1000         public void testGetPoliciesOfOriginOfNodeTemplate() {
1001                 NodeTemplate nt0 = csarHelperServicePolicy.getNodeTemplateByName("al_vf 0");
1002                 NodeTemplate nt1 = csarHelperServicePolicy.getNodeTemplateByName("al_vf 1");
1003                 List<Policy> policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplate(nt0);
1004                 assertNotNull(policies);
1005                 assertEquals(policies.size(), 3);
1006                 policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplate(nt1);
1007                 assertNotNull(policies);
1008                 assertEquals(policies.size(), 3);
1009         }
1010
1011         @Test
1012         public void testGetPoliciesOfOriginOfNodeTemplateByToscaPolicyType() {
1013                 NodeTemplate nt0 = csarHelperServicePolicy.getNodeTemplateByName("al_vf 0");
1014                 NodeTemplate nt1 = csarHelperServicePolicy.getNodeTemplateByName("al_vf 1");
1015                 List<Policy> policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(nt0, "org.openecomp.policies.placement.Colocate");
1016                 assertNotNull(policies);
1017                 assertEquals(policies.size(), 1);
1018
1019                 policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(nt0, "org.openecomp.policies.placement.Antilocate");
1020                 assertNotNull(policies);
1021                 assertEquals(policies.size(), 1);
1022
1023                 policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(nt0, "org.openecomp.policies.placement.valet.Diversity");
1024                 assertNotNull(policies);
1025                 assertEquals(policies.size(), 1);
1026
1027                 policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(nt1, "org.openecomp.policies.placement.Colocate");
1028                 assertNotNull(policies);
1029                 assertEquals(policies.size(), 1);
1030
1031                 policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(nt1, "org.openecomp.policies.placement.Antilocate");
1032                 assertNotNull(policies);
1033                 assertEquals(policies.size(), 1);
1034
1035                 policies = csarHelperServicePolicy.getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(nt1, "org.openecomp.policies.placement.valet.Diversity");
1036                 assertNotNull(policies);
1037                 assertEquals(policies.size(), 1);
1038         }
1039
1040         @Test
1041         public void testGetPolicyTargetNodeTemplatesFromOrigin() {
1042                 List<NodeTemplate> nodeTemplates = csarHelperServicePolicy.getPolicyTargetsFromOrigin(csarHelperServicePolicy.getNodeTemplateByName("al_vf 1"),"policy..Colocate..0");
1043                 assertNotNull(nodeTemplates);
1044                 assertEquals(nodeTemplates.size(), 2);
1045         }
1046
1047         @Test
1048         public void testGetPoliciesOfNodeTemplate() {
1049                 NodeTemplate nt0 = csarHelperVfPolicy.getNodeTemplateByName("al_vfc 1");
1050                 List<Policy> policies = csarHelperVfPolicy.getPoliciesOfTarget(nt0);
1051                 assertNotNull(policies);
1052                 assertEquals(policies.size(), 1);
1053         }
1054
1055         @Test
1056         public void testGetPoliciesOfNodeTemplateByToscaPolicyType() {
1057                 NodeTemplate nt0 = csarHelperVfPolicy.getNodeTemplateByName("al_vfc 1");
1058                 List<Policy> policies = csarHelperVfPolicy.getPoliciesOfTargetByToscaPolicyType(nt0, "org.openecomp.policies.placement.Colocate");
1059                 assertNotNull(policies);
1060                 assertEquals(policies.size(), 1);
1061         }
1062
1063         @Test
1064         public void testGetPoliciesOfTopologyTemplate() {
1065                 List<Policy> policies = csarHelperVfPolicy.getPoliciesOfTopologyTemplate();
1066                 assertNotNull(policies);
1067                 assertEquals(policies.size(), 1);
1068         }
1069
1070         @Test
1071         public void testGetPolicyTargetNodeTemplates() {
1072                 List<NodeTemplate> nodeTemplates = csarHelperVfPolicy.getPolicyTargetsFromTopologyTemplate("policy..Colocate..0");
1073                 assertNotNull(nodeTemplates);
1074                 assertEquals(nodeTemplates.size(), 2);
1075         }
1076
1077         @Test
1078         public void testGetGroups() {
1079                 NodeTemplate groupsVf = csarHelperServiceGroups.getNodeTemplateByName("GroupsVf 0");
1080                 NodeTemplate vlanGroups = csarHelperServiceGroups.getNodeTemplateByName("VlanGroups 0");
1081
1082                 ArrayList<Group> groups = csarHelperServiceGroups.getGroupsOfOriginOfNodeTemplate(groupsVf);
1083                 assertNotNull(groups);
1084                 assertEquals(groups.size(), 5);
1085
1086                 groups = csarHelperServiceGroups.getGroupsOfOriginOfNodeTemplate(vlanGroups);
1087                 assertNotNull(groups);
1088                 assertEquals(groups.size(), 4);
1089
1090                 groups = csarHelperServiceGroups.getGroupsOfOriginOfNodeTemplateByToscaGroupType(groupsVf, "org.openecomp.groups.VfcInstanceGroup");
1091                 assertNotNull(groups);
1092                 assertEquals(groups.size(), 1);
1093
1094                 groups = csarHelperServiceGroups.getGroupsOfOriginOfNodeTemplateByToscaGroupType(vlanGroups, "org.openecomp.groups.VfcInstanceGroup");
1095                 assertNotNull(groups);
1096                 assertEquals(groups.size(), 2);
1097
1098                 List<NodeTemplate> members = csarHelperServiceGroups.getGroupMembersOfOriginOfNodeTemplate(groupsVf, "x_group");
1099
1100                 assertNotNull(members);
1101                 assertEquals(members.size(), 3);
1102                 Optional<NodeTemplate> memberOpt = (members.stream().filter(m -> m.getName().equals("lb_1"))).findFirst();
1103                 assertTrue(memberOpt.isPresent());
1104                 memberOpt = (members.stream().filter(m -> m.getName().equals("lb_2"))).findFirst();
1105                 assertTrue(memberOpt.isPresent());
1106                 memberOpt = (members.stream().filter(m -> m.getName().equals("mg_4"))).findFirst();
1107                 assertTrue(memberOpt.isPresent());
1108
1109                 members = csarHelperServiceGroups.getGroupMembersOfOriginOfNodeTemplate(vlanGroups, "oam_group");
1110                 assertNotNull(members);
1111                 assertEquals(members.size(), 1);
1112                 memberOpt = (members.stream().filter(m -> m.getName().equals("abstract_vdbe_1"))).findFirst();
1113                 assertTrue(memberOpt.isPresent());
1114
1115                 members = csarHelperServiceGroups.getGroupMembersOfOriginOfNodeTemplate(vlanGroups, "untr_group");
1116                 assertNotNull(members);
1117                 assertEquals(members.size(), 1);
1118                 memberOpt = (members.stream().filter(m -> m.getName().equals("abstract_vdbe"))).findFirst();
1119                 assertTrue(memberOpt.isPresent());
1120         }
1121
1122         @Test
1123         public void testGetGroupsInputsProperties() {
1124                 NodeTemplate vdbe0 = csarHelperServiceGroupsInputs.getNodeTemplateByName("vDBE 0");
1125                 ArrayList<Group> groups = csarHelperServiceGroupsInputs.getGroupsOfOriginOfNodeTemplate(vdbe0);
1126                 assertNotNull(groups);
1127                 assertEquals(groups.size(), 4);
1128
1129                 Optional<Group> groupOpt = (groups.stream().filter(g -> g.getName().equals("oam_group"))).findFirst();
1130                 assertTrue(groupOpt.isPresent());
1131                 Group group = groupOpt.get();
1132                 validateInputsProperties(vdbe0, group);
1133
1134                 groupOpt = (groups.stream().filter(g -> g.getName().equals("untr_group"))).findFirst();
1135                 assertTrue(groupOpt.isPresent());
1136                 group = groupOpt.get();
1137                 validateInputsProperties(vdbe0, group);
1138         }
1139
1140         @Test
1141         public void testGetGroupsInputsCapabilities() {
1142                 NodeTemplate vdbe = csarHelperServiceGroupsCapabilities.getNodeTemplateByName("vdbe_srv_proxy 0");
1143                 CapabilityAssignments capabilities = csarHelperServiceGroupsCapabilities.getCapabilitiesOf(vdbe);
1144                 CapabilityAssignment capability = capabilities.getCapabilityByName("vdbe0.oam_group.vlan_assignment");
1145                 assertNotNull(capability);
1146         }
1147
1148         @Test
1149         public void testGetVfGroupsPolicies() {
1150                 List<Policy> policies = csarHelperVfGroupsPolicies.getPoliciesOfTopologyTemplate();
1151                 assertNotNull(policies);
1152                 List<Group> groups = csarHelperVfGroupsPolicies.getGroupsOfTopologyTemplate();
1153                 assertNotNull(groups);
1154         }
1155
1156         @Test
1157         public void testGetServiceGroupsPolicies() {
1158                 NodeTemplate nt = csarHelperServiceGroupsPolicies.getNodeTemplateByName("vDBE 0");
1159                 List<Policy> policies = csarHelperServiceGroupsPolicies.getPoliciesOfOriginOfNodeTemplate(nt);
1160                 assertNotNull(policies);
1161                 List<Group> groups = csarHelperServiceGroupsPolicies.getGroupsOfOriginOfNodeTemplate(nt);
1162                 assertNotNull(groups);
1163         }
1164
1165         @Test
1166         public void testGetResourceInputsWithAnnotations() {
1167                 List<Input> inputs = csarHelperServiceAnnotations.getServiceInputs();
1168                 assertNotNull(inputs);
1169                 assertEquals(inputs.size(), 19);
1170                 assertTrue(inputs.stream().filter(i -> i.getAnnotations() != null).collect(Collectors.toList()).isEmpty());
1171
1172                 inputs = csarHelperServiceAnnotations.getInputsWithAnnotations();
1173                 assertNotNull(inputs);
1174                 assertEquals(inputs.size(), 19);
1175                 validateInputsAnnotations(inputs);
1176         }
1177
1178         @Test
1179         public void testGetServiceInputsWithAnnotations() {
1180                 List<Input> inputs = csarHelperServiceAdiodAnnotations.getServiceInputs();
1181                 assertNotNull(inputs);
1182                 assertTrue(inputs.stream().filter(i -> i.getAnnotations() != null).collect(Collectors.toList()).isEmpty());
1183
1184                 inputs = csarHelperServiceAdiodAnnotations.getInputsWithAnnotations();
1185                 assertNotNull(inputs);
1186                 validateInputsAnnotations(inputs);
1187         }
1188
1189         @SuppressWarnings("unchecked")
1190         private void validateInputsProperties(NodeTemplate vdbe0, Group group) {
1191                 assertNotNull(group.getPropertiesObjects());
1192                 ArrayList<Property> properties = group.getPropertiesObjects();
1193
1194                 List<String> inputs = properties.stream()
1195                 .filter(p -> p.getValue() instanceof Map)
1196                 .map(p -> ((Map<String, String>)p.getValue()).get("get_input"))
1197                 .collect(Collectors.toList());
1198
1199                 assertEquals(inputs.size(), 2);
1200
1201                 inputs.forEach(i -> assertTrue(vdbe0.getProperties().containsKey(i)));
1202
1203                  List<Object> list = vdbe0.getProperties().entrySet().stream()
1204                                  .filter(e -> inputs.contains(e.getKey()))
1205                                  .map(e -> e.getValue().getValue())
1206                                  .collect(Collectors.toList());
1207                  assertEquals(list.size(), 2);
1208         }
1209
1210         private void validateInputsAnnotations(List<Input> inputs) {
1211                 List<Input> inputsWithAnnotations = inputs.stream().filter(i -> i.getAnnotations() != null).collect(Collectors.toList());
1212                 assertTrue(!inputs.isEmpty());
1213                 inputsWithAnnotations.stream().forEach(i -> validateAnnotations(i));
1214         }
1215
1216         private void validateAnnotations(Input input) {
1217                 assertNotNull(input.getAnnotations());
1218                 assertEquals(input.getAnnotations().size(), 1);
1219                 Annotation annotation = input.getAnnotations().get("source");
1220                 assertEquals(annotation.getName(), "source");
1221                 assertEquals(annotation.getType().toLowerCase(), "org.openecomp.annotations.source");
1222                 assertNotNull(annotation.getProperties());
1223                 Optional<Property> source_type = annotation.getProperties()
1224                                 .stream()
1225                                 .filter(p->p.getName().equals("source_type"))
1226                                 .findFirst();
1227                 assertTrue(source_type.isPresent());
1228                 assertEquals(source_type.get().getValue(), "HEAT");
1229         }
1230
1231 }
1232
1233