integration-tests/src/test/java/org/onap/sdc/frontend/ci/tests/execute/sanity/EtsiNetworkServiceUiTests.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.onap.sdc.frontend.ci.tests.execute.sanity;
  21
  22 import static org.hamcrest.MatcherAssert.assertThat;
  23 import static org.hamcrest.Matchers.empty;
  24 import static org.hamcrest.Matchers.hasKey;
  25 import static org.hamcrest.Matchers.hasSize;
  26 import static org.hamcrest.Matchers.is;
  27 import static org.hamcrest.Matchers.not;
  28 import static org.hamcrest.Matchers.notNullValue;
  29 import static org.junit.Assert.fail;
  30
  31 import com.aventstack.extentreports.Status;
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Map.Entry;
  36 import java.util.Optional;
  37 import java.util.Set;
  38 import org.apache.commons.io.FilenameUtils;
  39 import org.junit.jupiter.api.Assertions;
  40 import org.onap.sdc.backend.ci.tests.datatypes.enums.ComponentType;
  41 import org.onap.sdc.backend.ci.tests.datatypes.enums.PackageTypeEnum;
  42 import org.onap.sdc.backend.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  43 import org.onap.sdc.backend.ci.tests.utils.general.ElementFactory;
  44 import org.onap.sdc.frontend.ci.tests.datatypes.CategorySelect;
  45 import org.onap.sdc.frontend.ci.tests.datatypes.ComponentData;
  46 import org.onap.sdc.frontend.ci.tests.datatypes.ComponentProperty;
  47 import org.onap.sdc.frontend.ci.tests.datatypes.ModelName;
  48 import org.onap.sdc.frontend.ci.tests.datatypes.ServiceCreateData;
  49 import org.onap.sdc.frontend.ci.tests.datatypes.VspCreateData;
  50 import org.onap.sdc.frontend.ci.tests.datatypes.VspOnboardingProcedure;
  51 import org.onap.sdc.frontend.ci.tests.datatypes.composition.RelationshipInformation;
  52 import org.onap.sdc.frontend.ci.tests.exception.UnzipException;
  53 import org.onap.sdc.frontend.ci.tests.execute.setup.DriverFactory;
  54 import org.onap.sdc.frontend.ci.tests.execute.setup.ExtentTestActions;
  55 import org.onap.sdc.frontend.ci.tests.execute.setup.SetupCDTest;
  56 import org.onap.sdc.frontend.ci.tests.flow.AddNodeToCompositionFlow;
  57 import org.onap.sdc.frontend.ci.tests.flow.CheckComponentPropertiesFlow;
  58 import org.onap.sdc.frontend.ci.tests.flow.CreateResourceFromVspFlow;
  59 import org.onap.sdc.frontend.ci.tests.flow.CreateServiceFlow;
  60 import org.onap.sdc.frontend.ci.tests.flow.CreateVlmFlow;
  61 import org.onap.sdc.frontend.ci.tests.flow.CreateVspFlow;
  62 import org.onap.sdc.frontend.ci.tests.flow.DownloadCsarArtifactFlow;
  63 import org.onap.sdc.frontend.ci.tests.flow.EditComponentPropertiesFlow;
  64 import org.onap.sdc.frontend.ci.tests.flow.ImportVspFlow;
  65 import org.onap.sdc.frontend.ci.tests.flow.composition.CreateRelationshipFlow;
  66 import org.onap.sdc.frontend.ci.tests.flow.exception.UiTestFlowRuntimeException;
  67 import org.onap.sdc.frontend.ci.tests.pages.ComponentPage;
  68 import org.onap.sdc.frontend.ci.tests.pages.ResourceCreatePage;
  69 import org.onap.sdc.frontend.ci.tests.pages.ServiceComponentPage;
  70 import org.onap.sdc.frontend.ci.tests.pages.TopNavComponent;
  71 import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionDetailSideBarComponent;
  72 import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionDetailSideBarComponent.CompositionDetailTabName;
  73 import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionPage;
  74 import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionRequirementsCapabilitiesTab;
  75 import org.onap.sdc.frontend.ci.tests.pages.component.workspace.ToscaArtifactsPage;
  76 import org.onap.sdc.frontend.ci.tests.pages.home.HomePage;
  77 import org.onap.sdc.frontend.ci.tests.utilities.FileHandling;
  78 import org.openecomp.sdc.be.model.ComponentInstance;
  79 import org.openqa.selenium.WebDriver;
  80 import org.slf4j.Logger;
  81 import org.slf4j.LoggerFactory;
  82 import org.testng.annotations.Test;
  83 import org.yaml.snakeyaml.Yaml;
  84
  85 public class EtsiNetworkServiceUiTests extends SetupCDTest {
  86
  87     private static final Logger LOGGER = LoggerFactory.getLogger(EtsiNetworkServiceUiTests.class);
  88
  89     private WebDriver webDriver;
  90     private ComponentInstance virtualLinkableVnf1;
  91     private ComponentInstance virtualLinkableVnf2;
  92     private ComponentInstance nsVirtualLink;
  93
  94     @Test
  95     public void etsiNetworkServiceTest() throws UnzipException {
  96         webDriver = DriverFactory.getDriver();
  97
  98         createVlm();
  99         final String resourceName = createVsp();
 100         ResourceCreatePage resourceCreatePage = importVsp(resourceName);
 101         resourceCreatePage = createAndCertifyVf(resourceName, resourceCreatePage);
 102         resourceCreatePage.isLoaded();
 103         final HomePage homePage = resourceCreatePage.goToHomePage();
 104         homePage.isLoaded();
 105
 106         final ServiceCreateData serviceCreateData = createServiceFormData();
 107         final CreateServiceFlow createServiceFlow = createService(serviceCreateData);
 108
 109         final CheckComponentPropertiesFlow checkComponentPropertiesFlow = checkServiceProperties();
 110         ComponentPage componentPage = checkComponentPropertiesFlow.getLandedPage()
 111             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ServiceComponentPage"));
 112
 113         //adding node
 114         componentPage = addNodesAndCreateRelationships(resourceName, serviceCreateData, componentPage);
 115
 116         final Map<String, Object> propertyMap = createPropertyToEditMap();
 117         editProperties(componentPage, propertyMap);
 118
 119         final DownloadCsarArtifactFlow downloadCsarArtifactFlow = downloadCsarArtifact(componentPage);
 120         final ToscaArtifactsPage toscaArtifactsPage = downloadCsarArtifactFlow.getLandedPage()
 121             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ToscaArtifactsPage"));
 122
 123         assertThat("No artifact download was found", toscaArtifactsPage.getDownloadedArtifactList(), not(empty()));
 124
 125         final String downloadedCsarName = toscaArtifactsPage.getDownloadedArtifactList().get(0);
 126         propertyMap.entrySet().removeIf(e -> e.getValue() == null);
 127         checkEtsiNsPackage(createServiceFlow.getServiceCreateData().getName(), downloadedCsarName, propertyMap);
 128     }
 129
 130     private ServiceComponentPage addNodesAndCreateRelationships(final String resourceName, final ServiceCreateData serviceCreateData,
 131                                                                 final ComponentPage componentPage) {
 132         //add first VF node
 133         final ComponentData parentComponent = new ComponentData();
 134         parentComponent.setName(serviceCreateData.getName());
 135         parentComponent.setVersion("0.1");
 136         parentComponent.setComponentType(ComponentType.SERVICE);
 137         final ComponentData resourceToAdd = new ComponentData();
 138         resourceToAdd.setName(resourceName);
 139         resourceToAdd.setVersion("1.0");
 140         resourceToAdd.setComponentType(ComponentType.RESOURCE);
 141         CompositionPage compositionPage = componentPage.goToComposition();
 142         AddNodeToCompositionFlow addNodeToCompositionFlow = addNodeToComposition(parentComponent, resourceToAdd, compositionPage);
 143         virtualLinkableVnf1 = addNodeToCompositionFlow.getCreatedComponentInstance()
 144             .orElseThrow(() -> new UiTestFlowRuntimeException("Could not get the created component instance"));
 145         //add second VF node
 146         addNodeToCompositionFlow = addNodeToComposition(parentComponent, resourceToAdd, compositionPage);
 147         virtualLinkableVnf2 = addNodeToCompositionFlow.getCreatedComponentInstance()
 148             .orElseThrow(() -> new UiTestFlowRuntimeException("Could not get the created component instance"));
 149         //add NsVirtualLink node
 150         final ComponentData nsVirtualLinkToAdd = new ComponentData();
 151         nsVirtualLinkToAdd.setName("NsVirtualLink");
 152         nsVirtualLinkToAdd.setVersion("1.0");
 153         nsVirtualLinkToAdd.setComponentType(ComponentType.RESOURCE);
 154         addNodeToCompositionFlow = addNodeToComposition(parentComponent, nsVirtualLinkToAdd, compositionPage);
 155         nsVirtualLink = addNodeToCompositionFlow.getCreatedComponentInstance()
 156             .orElseThrow(() -> new UiTestFlowRuntimeException("Could not get the created component instance"));
 157
 158         //create a relationship from NsVirtualLink to first VF
 159         final String virtualLinkableCapability = "tosca.capabilities.nfv.VirtualLinkable";
 160         compositionPage = createRelationship(compositionPage, nsVirtualLink.getName(), virtualLinkableCapability,
 161             virtualLinkableVnf1.getName(), virtualLinkableCapability);
 162         CreateRelationshipFlow createRelationshipFlow;
 163         //create a relationship from NsVirtualLink to second VF
 164         final RelationshipInformation relationshipInfoVirtualLinkToVnf2 =
 165             new RelationshipInformation(nsVirtualLink.getName(), virtualLinkableCapability, virtualLinkableVnf2.getName(), virtualLinkableCapability);
 166         createRelationshipFlow = new CreateRelationshipFlow(webDriver, relationshipInfoVirtualLinkToVnf2);
 167         compositionPage = (CompositionPage) createRelationshipFlow.run(compositionPage)
 168             .orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a CompositionPage instance"));
 169         final ServiceComponentPage serviceComponentPage = compositionPage.goToServiceGeneral();
 170         serviceComponentPage.isLoaded();
 171         return serviceComponentPage;
 172     }
 173
 174     private ResourceCreatePage createAndCertifyVf(final String resourceName, final ResourceCreatePage resourceCreatePage) {
 175         final CreateResourceFromVspFlow createResourceFlow = new CreateResourceFromVspFlow(webDriver, resourceName);
 176         final ResourceCreatePage resourceCreatePage1 = createResourceFlow.run(resourceCreatePage)
 177             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected return ResourceCreatePage"));
 178         resourceCreatePage1.isLoaded();
 179         final CompositionPage compositionPage = resourceCreatePage1.goToComposition();
 180         compositionPage.isLoaded();
 181         //selecting node
 182         final String mgmtPortNodeName = "mgmt_port";
 183         compositionPage.selectNode(mgmtPortNodeName);
 184         final CompositionDetailSideBarComponent detailSideBar = compositionPage.getDetailSideBar();
 185         detailSideBar.isLoaded();
 186         //going to requirements and capabilities tab and externalizing requirement
 187         final CompositionRequirementsCapabilitiesTab compositionRequirementsCapabilitiesTab =
 188             (CompositionRequirementsCapabilitiesTab) detailSideBar.selectTab(CompositionDetailTabName.REQUIREMENTS_CAPABILITIES);
 189         compositionRequirementsCapabilitiesTab.isLoaded();
 190         ExtentTestActions.takeScreenshot(Status.INFO, "requirement-capabilities-tab-loaded", "Requirement and Capabilities tab is loaded");
 191         compositionRequirementsCapabilitiesTab.clickOnRequirements();
 192         final String externalVirtualLinkRequirement = "external_virtual_link";
 193         getExtendTest().log(Status.INFO,
 194             String.format("Externalizing requirement '%s' in node '%s'", externalVirtualLinkRequirement, mgmtPortNodeName));
 195         compositionRequirementsCapabilitiesTab.toggleRequirementAsExternal(externalVirtualLinkRequirement);
 196         ExtentTestActions.takeScreenshot(Status.INFO, "requirement-externalized",
 197             String.format("Requirement '%s' of node '%s' was externalized", externalVirtualLinkRequirement, mgmtPortNodeName));
 198
 199         final ComponentPage componentPage = compositionPage.goToGeneral();
 200         componentPage.isLoaded();
 201         componentPage.certifyComponent();
 202         return resourceCreatePage1;
 203     }
 204
 205     private CompositionPage createRelationship(final CompositionPage compositionPage, final String fromComponentInstanceName,
 206                                                final String fromCapability, final String toComponentInstanceName, final String toRequirement) {
 207         final RelationshipInformation relationshipInformation =
 208             new RelationshipInformation(fromComponentInstanceName, fromCapability, toComponentInstanceName, toRequirement);
 209         CreateRelationshipFlow createRelationshipFlow = new CreateRelationshipFlow(webDriver, relationshipInformation);
 210         return (CompositionPage) createRelationshipFlow.run(compositionPage)
 211             .orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a CompositionPage instance"));
 212     }
 213
 214     private ResourceCreatePage importVsp(final String resourceName) {
 215         final ImportVspFlow importVspFlow = new ImportVspFlow(webDriver, resourceName);
 216         return importVspFlow.run()
 217             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected return ResourceCreatePage"));
 218     }
 219
 220     private String createVsp() {
 221         final String resourceName = ElementFactory.addRandomSuffixToName(ElementFactory.getResourcePrefix());
 222         final String virtualLinkableVnf = "etsi-vnf-virtual-linkable.csar";
 223         final String rootFolder = org.onap.sdc.backend.ci.tests.utils.general.FileHandling.getPackageRepositoryPath(PackageTypeEnum.VNF);
 224         var vspCreateData = new VspCreateData();
 225         vspCreateData.setName(resourceName);
 226         vspCreateData.setCategory(CategorySelect.COMMON_NETWORK_RESOURCES);
 227         vspCreateData.setDescription("description");
 228         vspCreateData.setOnboardingProcedure(VspOnboardingProcedure.NETWORK_PACKAGE);
 229         final CreateVspFlow createVspFlow = new CreateVspFlow(webDriver, vspCreateData, virtualLinkableVnf, rootFolder);
 230         createVspFlow.run(new TopNavComponent(webDriver));
 231         return resourceName;
 232     }
 233
 234     private void createVlm() {
 235         getExtendTest().log(Status.INFO, "Creating a VLM");
 236         final CreateVlmFlow createVlmFlow = new CreateVlmFlow(webDriver);
 237         createVlmFlow.run();
 238     }
 239
 240     public AddNodeToCompositionFlow addNodeToComposition(final ComponentData parentComponent, final ComponentData resourceToAdd,
 241                                                          CompositionPage compositionPage) {
 242
 243         final AddNodeToCompositionFlow addNodeToCompositionFlow = new AddNodeToCompositionFlow(webDriver, parentComponent, resourceToAdd);
 244         addNodeToCompositionFlow.run(compositionPage);
 245         return addNodeToCompositionFlow;
 246     }
 247
 248     private CreateServiceFlow createService(final ServiceCreateData serviceCreateData) {
 249         final CreateServiceFlow createServiceFlow = new CreateServiceFlow(webDriver, serviceCreateData);
 250         createServiceFlow.run(new HomePage(webDriver));
 251         return createServiceFlow;
 252     }
 253
 254     private CheckComponentPropertiesFlow checkServiceProperties() {
 255         final Set<ComponentProperty<?>> componentPropertySet = Set.of(
 256             new ComponentProperty<>("descriptor_id"),
 257             new ComponentProperty<>("designer"),
 258             new ComponentProperty<>("flavour_id"),
 259             new ComponentProperty<>("invariant_id"),
 260             new ComponentProperty<>("name"),
 261             new ComponentProperty<>("ns_profile"),
 262             new ComponentProperty<>("version"),
 263             new ComponentProperty<>("service_availability_level")
 264         );
 265
 266         final var checkVfPropertiesFlow = new CheckComponentPropertiesFlow(componentPropertySet, webDriver);
 267         checkVfPropertiesFlow.run();
 268         return checkVfPropertiesFlow;
 269     }
 270
 271     private void editProperties(final ComponentPage componentPage, final Map<String, Object> propertyMap) {
 272         final EditComponentPropertiesFlow editComponentPropertiesFlow = new EditComponentPropertiesFlow(webDriver, propertyMap);
 273         editComponentPropertiesFlow.run(componentPage);
 274     }
 275
 276     private DownloadCsarArtifactFlow downloadCsarArtifact(final ComponentPage componentPage) {
 277         final DownloadCsarArtifactFlow downloadCsarArtifactFlow = new DownloadCsarArtifactFlow(webDriver);
 278         downloadCsarArtifactFlow.run(componentPage);
 279         return downloadCsarArtifactFlow;
 280     }
 281
 282     private Map<String, Object> createPropertyToEditMap() {
 283         final Map<String, Object> propertyMap = new HashMap<>();
 284         propertyMap.put("designer", "designer1");
 285         propertyMap.put("descriptor_id", "descriptor_id1");
 286         propertyMap.put("flavour_id", "flavour_id1");
 287         propertyMap.put("invariant_id", "invariant_id1");
 288         propertyMap.put("name", "name1");
 289         propertyMap.put("version", "version1");
 290         propertyMap.put("service_availability_level", 1);
 291         //does not work yet with TOSCA complex types
 292         propertyMap.put("ns_profile", null);
 293         return propertyMap;
 294     }
 295
 296     private ServiceCreateData createServiceFormData() {
 297         final ServiceCreateData serviceCreateData = new ServiceCreateData();
 298         serviceCreateData.setRandomName("EtsiNfvNetworkService");
 299         serviceCreateData.setModel(ModelName.DEFAULT_MODEL_NAME.getName());
 300         serviceCreateData.setCategory(ServiceCategoriesEnum.ETSI_NFV_NETWORK_SERVICE.getValue());
 301         serviceCreateData.setEtsiVersion("2.5.1");
 302         serviceCreateData.setDescription("aDescription");
 303         return serviceCreateData;
 304     }
 305
 306     private void checkEtsiNsPackage(final String serviceName, final String downloadedCsarName,
 307                                     final Map<String, Object> expectedPropertyMap) throws UnzipException {
 308         final String downloadFolderPath = getConfig().getDownloadAutomationFolder();
 309         final Map<String, byte[]> filesFromZip = FileHandling.getFilesFromZip(downloadFolderPath, downloadedCsarName);
 310         final Optional<String> etsiPackageEntryOpt =
 311             filesFromZip.keySet().stream().filter(s -> s.startsWith("Artifacts/ETSI_PACKAGE")).findFirst();
 312         if (etsiPackageEntryOpt.isEmpty()) {
 313             Assertions.fail("Could not find the NSD package in Artifacts/ETSI_PACKAGE");
 314         }
 315         final String nodeType = String.format("org.openecomp.service.%s",
 316             serviceName.substring(0, 1).toUpperCase() + serviceName.substring(1).toLowerCase());
 317         final String etsiPackageEntry = etsiPackageEntryOpt.get();
 318         final String nsdPackageBaseName = FilenameUtils.getBaseName(etsiPackageEntry);
 319         final String nsdCsarFile = nsdPackageBaseName + ".csar";
 320         final byte[] etsiPackageBytes = filesFromZip.get(etsiPackageEntry);
 321         if (etsiPackageEntry.endsWith(".zip")) {
 322             final Map<String, byte[]> nsPackageFileMap = FileHandling.getFilesFromZip(etsiPackageBytes);
 323             assertThat("Expecting 3 files inside the NSD CSAR, the CSAR itself and its signature and certificate",
 324                 nsPackageFileMap.size(), is(3));
 325             assertThat("Expecting the NSD CSAR file " + nsdCsarFile, nsPackageFileMap, hasKey(nsdCsarFile));
 326             final String nsdCsarSignature = nsdPackageBaseName + ".cms";
 327             assertThat("Expecting the NSD CSAR signature " + nsdCsarSignature, nsPackageFileMap, hasKey(nsdCsarSignature));
 328             final String nsdCertificate = nsdPackageBaseName + ".cert";
 329             assertThat("Expecting the NSD CSAR certificate " + nsdCertificate, nsPackageFileMap, hasKey(nsdCertificate));
 330             checkNsCsar(nsdPackageBaseName, nodeType, expectedPropertyMap, nsPackageFileMap.get(nsdCsarFile));
 331             return;
 332         }
 333         if (etsiPackageEntry.endsWith(".csar")) {
 334             final Map<String, byte[]> nsPackageFileMap = FileHandling.getFilesFromZip(etsiPackageBytes);
 335             checkNsCsar(nsdPackageBaseName, nodeType, expectedPropertyMap, nsPackageFileMap.get(nsdCsarFile));
 336             return;
 337         }
 338         fail(String.format("Unexpected ETSI NS PACKAGE entry '%s'. Expecting a '.csar' or '.zip'", etsiPackageEntry));
 339     }
 340
 341     private void checkNsCsar(final String expectedServiceName, final String expectedServiceNodeType, final Map<String, Object> expectedPropertiesMap,
 342                              final byte[] nsCsar) throws UnzipException {
 343         final Map<String, byte[]> csarFileMap = FileHandling.getFilesFromZip(nsCsar);
 344
 345         final String mainDefinitionFile = String.format("Definitions/%s.yaml", expectedServiceName);
 346         final byte[] mainDefinitionFileBytes = csarFileMap.get(mainDefinitionFile);
 347         if (mainDefinitionFileBytes == null) {
 348             fail(String.format("Could not find the Main Definition file in '%s'", mainDefinitionFile));
 349         }
 350
 351         final Map<String, Object> mainDefinitionYamlMap = loadYamlObject(mainDefinitionFileBytes);
 352         final Map<String, Object> topologyTemplateTosca = getMapEntry(mainDefinitionYamlMap, "topology_template");
 353         assertThat(String.format("'%s' should contain a topology_template entry", mainDefinitionFile), topologyTemplateTosca, notNullValue());
 354         final Map<String, Object> substitutionMappingsTosca = getMapEntry(topologyTemplateTosca, "substitution_mappings");
 355         assertThat(String.format("'%s' should contain a substitution_mappings entry", mainDefinitionFile), substitutionMappingsTosca, notNullValue());
 356         final String nodeType = (String) substitutionMappingsTosca.get("node_type");
 357         assertThat("substitution_mappings->node_type should be as expected", nodeType, is(expectedServiceNodeType));
 358
 359         final Map<String, Object> nodeTemplatesTosca = getMapEntry(topologyTemplateTosca, "node_templates");
 360         assertThat(String.format("'%s' should contain a node_templates entry", mainDefinitionFile), nodeTemplatesTosca, notNullValue());
 361
 362         checkVirtualLinkableNode(mainDefinitionFile, virtualLinkableVnf1, nodeTemplatesTosca);
 363         checkVirtualLinkableNode(mainDefinitionFile, virtualLinkableVnf2, nodeTemplatesTosca);
 364         //checking tosca.nodes.nfv.NsVirtualLink node
 365         final Map<String, Object> nsVirtualLinkNode = getMapEntry(nodeTemplatesTosca, nsVirtualLink.getName());
 366         assertThat(String.format("'%s' should contain a '%s' entry in node_templates", mainDefinitionFile, nsVirtualLink.getName()),
 367             nsVirtualLinkNode, notNullValue());
 368         assertThat(String.format("Type from '%s' should be as expected", nsVirtualLink.getName()),
 369             nsVirtualLinkNode.get("type"), is("tosca.nodes.nfv.NsVirtualLink"));
 370
 371         //checking the main service node
 372         final Map<String, Object> serviceNodeTemplate = getMapEntry(nodeTemplatesTosca, expectedServiceNodeType);
 373         assertThat(String.format("'%s' should contain a '%s' entry in node_templates", mainDefinitionFile, expectedServiceNodeType),
 374             serviceNodeTemplate, notNullValue());
 375         final Map<String, Object> properties = getMapEntry(serviceNodeTemplate, "properties");
 376         assertThat(String.format("'%s' node template in '%s' should contain a properties entry", expectedServiceNodeType, mainDefinitionFile),
 377             properties, notNullValue());
 378         assertThat(String.format("'%s' node template should contain '%s' properties", expectedServiceNodeType, expectedPropertiesMap.size()),
 379             properties.size(), is(expectedPropertiesMap.size()));
 380         for (final Entry<String, Object> expectedPropertyEntry : expectedPropertiesMap.entrySet()) {
 381             final String expectedPropertyName = expectedPropertyEntry.getKey();
 382             assertThat(String.format("'%s' node template should contain the property '%s'", expectedServiceNodeType, expectedPropertyName),
 383                 properties, hasKey(expectedPropertyName));
 384             final Object expectedPropertyValue = expectedPropertyEntry.getValue();
 385             if (expectedPropertyValue != null) {
 386                 final Object actualPropertyValue = properties.get(expectedPropertyName);
 387                 final String msg = String.format("The property '%s', in '%s' node template should have the expected value '%s'",
 388                     expectedPropertyName, expectedServiceNodeType, actualPropertyValue);
 389                 assertThat(msg, actualPropertyValue, is(expectedPropertyValue));
 390             }
 391         }
 392     }
 393
 394     private void checkVirtualLinkableNode(final String mainDefinitionFileName, final ComponentInstance virtualLinkableVnf,
 395                                           final Map<String, Object> nodeTemplatesTosca) {
 396         final Map<String, Object> virtualLinkableVnfNode = getMapEntry(nodeTemplatesTosca, virtualLinkableVnf.getName());
 397         assertThat(String.format("'%s' should contain a '%s' entry in node_templates", mainDefinitionFileName, virtualLinkableVnf.getName()),
 398             virtualLinkableVnfNode, notNullValue());
 399         assertThat(String.format("Type from '%s' should be as expected", virtualLinkableVnf.getName()),
 400             virtualLinkableVnfNode.get("type"), is("org.openecomp.resource.EtsiVnfVirtualLinkable"));
 401         final Object requirementsObj = virtualLinkableVnfNode.get("requirements");
 402         assertThat(String.format("'%s' should contain a requirements entry in node_templates", virtualLinkableVnf.getName()),
 403             requirementsObj, notNullValue());
 404         if (!(requirementsObj instanceof List)) {
 405             fail(String.format("Requirements in '%s' is not a list", virtualLinkableVnf.getName()));
 406         }
 407         final var requirements = (List<Map<String, Object>>) requirementsObj;
 408         assertThat(String.format("'%s' should contain only one requirement", virtualLinkableVnf.getName()), requirements, hasSize(1));
 409         final Map<String, Object> externalVirtualLinkRequirement = getMapEntry(requirements.get(0), "external_virtual_link");
 410         assertThat(String.format("'%s' should contain the requirement 'external_virtual_link'", virtualLinkableVnf.getName()),
 411             externalVirtualLinkRequirement, notNullValue());
 412         assertThat(
 413             String.format("Requirement 'external_virtual_link' in '%s' should contain the capability 'virtual_linkable'",
 414                 virtualLinkableVnf.getName()),
 415             externalVirtualLinkRequirement.get("capability"), is("virtual_linkable"));
 416         assertThat(
 417             String.format("Requirement 'external_virtual_link' in '%s' should relate to the node '%s'",
 418                 virtualLinkableVnf.getName(), nsVirtualLink.getName()),
 419             externalVirtualLinkRequirement.get("node"), is(nsVirtualLink.getName()));
 420     }
 421
 422     private Map<String, Object> getMapEntry(final Map<String, Object> yamlObj, final String entryName) {
 423         try {
 424             return (Map<String, Object>) yamlObj.get(entryName);
 425         } catch (final Exception e) {
 426             final String errorMsg = String.format("Could not get the '%s' entry.", entryName);
 427             LOGGER.error(errorMsg, e);
 428             fail(errorMsg + "Error message: " + e.getMessage());
 429         }
 430         return null;
 431     }
 432
 433     private Map<String, Object> loadYamlObject(final byte[] mainDefinitionFileBytes) {
 434         return new Yaml().load(new String(mainDefinitionFileBytes));
 435     }
 436
 437 }
 438