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