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

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