integration-tests/src/test/java/org/onap/sdc/frontend/ci/tests/execute/sanity/ServiceTemplateDesignUiTests.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.anEmptyMap;
  24 import static org.hamcrest.Matchers.empty;
  25 import static org.hamcrest.Matchers.emptyString;
  26 import static org.hamcrest.Matchers.hasSize;
  27 import static org.hamcrest.Matchers.is;
  28 import static org.hamcrest.Matchers.not;
  29 import static org.hamcrest.Matchers.notNullValue;
  30 import static org.junit.jupiter.api.Assertions.assertEquals;
  31 import static org.junit.jupiter.api.Assertions.assertNotNull;
  32 import static org.junit.jupiter.api.Assertions.assertTrue;
  33 import static org.junit.jupiter.api.Assertions.fail;
  34
  35 import com.aventstack.extentreports.Status;
  36 import java.io.IOException;
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.HashMap;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.Map.Entry;
  43 import java.util.Optional;
  44 import java.util.stream.Collectors;
  45 import org.onap.sdc.backend.ci.tests.data.providers.OnboardingDataProviders;
  46 import org.onap.sdc.backend.ci.tests.datatypes.enums.ComponentType;
  47 import org.onap.sdc.backend.ci.tests.datatypes.enums.ResourceCategoryEnum;
  48 import org.onap.sdc.backend.ci.tests.utils.general.ElementFactory;
  49 import org.onap.sdc.frontend.ci.tests.datatypes.ComponentData;
  50 import org.onap.sdc.frontend.ci.tests.datatypes.ResourceCreateData;
  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.AddComponentPropertyFlow;
  57 import org.onap.sdc.frontend.ci.tests.flow.AddNodeToCompositionFlow;
  58 import org.onap.sdc.frontend.ci.tests.flow.CreateVfFlow;
  59 import org.onap.sdc.frontend.ci.tests.flow.CreateVfcFlow;
  60 import org.onap.sdc.frontend.ci.tests.flow.DownloadCsarArtifactFlow;
  61 import org.onap.sdc.frontend.ci.tests.flow.EditComponentPropertiesFlow;
  62 import org.onap.sdc.frontend.ci.tests.flow.composition.CreateRelationshipFlow;
  63 import org.onap.sdc.frontend.ci.tests.flow.exception.UiTestFlowRuntimeException;
  64 import org.onap.sdc.frontend.ci.tests.pages.AttributesOutputsPage;
  65 import org.onap.sdc.frontend.ci.tests.pages.ComponentPage;
  66 import org.onap.sdc.frontend.ci.tests.pages.ResourceCreatePage;
  67 import org.onap.sdc.frontend.ci.tests.pages.TopNavComponent;
  68 import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionPage;
  69 import org.onap.sdc.frontend.ci.tests.pages.component.workspace.ToscaArtifactsPage;
  70 import org.onap.sdc.frontend.ci.tests.pages.home.HomePage;
  71 import org.onap.sdc.frontend.ci.tests.utilities.FileHandling;
  72 import org.openecomp.sdc.be.model.ComponentInstance;
  73 import org.openqa.selenium.WebDriver;
  74 import org.slf4j.Logger;
  75 import org.slf4j.LoggerFactory;
  76 import org.testng.annotations.BeforeMethod;
  77 import org.testng.annotations.Test;
  78 import org.yaml.snakeyaml.Yaml;
  79
  80 public class ServiceTemplateDesignUiTests extends SetupCDTest {
  81
  82     private static final Logger LOGGER = LoggerFactory.getLogger(ServiceTemplateDesignUiTests.class);
  83
  84     private WebDriver webDriver;
  85     private TopNavComponent topNavComponent;
  86     private HomePage homePage;
  87     private List<ResourceCreateData> vfcs = new ArrayList<>();
  88     private ResourceCreateData vfResourceCreateData;
  89     private ComponentInstance networkFunctionInstance;
  90     private ComponentInstance networkServiceInstance;
  91     private AddNodeToCompositionFlow addNodeToCompositionFlow;
  92     private ComponentPage componentPage;
  93     private Map<String, String> propertiesToBeAddedMap;
  94
  95     @BeforeMethod
  96     public void init() {
  97         webDriver = DriverFactory.getDriver();
  98         topNavComponent = new TopNavComponent(webDriver);
  99         homePage = new HomePage(webDriver);
 100     }
 101
 102     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "vfcList")
 103     public void importAndCertifyVfc(final String rootFolder, final String vfcFilename) {
 104         setLog(vfcFilename);
 105         final String resourceName = ElementFactory.addRandomSuffixToName(ElementFactory.getResourcePrefix());
 106         final CreateVfcFlow createVfcFlow = createVFC(rootFolder + vfcFilename, resourceName);
 107         vfcs.stream().filter(vfc -> vfc.getName().startsWith(resourceName)).findFirst().orElseThrow(
 108             () -> new UiTestFlowRuntimeException(String.format("VFCs List should contain a VFC with the expected name %s", resourceName)));
 109         final ResourceCreatePage vfcResourceCreatePage = createVfcFlow.getLandedPage()
 110             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ResourceCreatePage"));
 111         vfcResourceCreatePage.isLoaded();
 112         vfcResourceCreatePage.certifyComponent();
 113         ExtentTestActions.takeScreenshot(Status.INFO, "vfc-certified",
 114             String.format("VFC '%s' was certified", resourceName));
 115     }
 116
 117     @Test(dependsOnMethods = "importAndCertifyVfc")
 118     public void createBaseService() throws UnzipException {
 119         final CreateVfFlow createVfFlow = createVF();
 120         addNodeToCompositionFlow = addNodeToCompositionAndCreateRelationship(createVfFlow);
 121         final CompositionPage compositionPage = addNodeToCompositionFlow.getLandedPage()
 122             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected return CompositionPage"));
 123         compositionPage.isLoaded();
 124         componentPage = compositionPage.goToGeneral();
 125         componentPage.isLoaded();
 126         downloadAndVerifyCsarPackageAfterBaseServiceCreation(componentPage);
 127     }
 128
 129     @Test(dependsOnMethods = "createBaseService")
 130     public void addComponentProperty() throws UnzipException {
 131         propertiesToBeAddedMap = loadPropertiesToAdd();
 132         addProperty(propertiesToBeAddedMap);
 133         componentPage = addValueToProperty(loadPropertiesToEdit());
 134         componentPage.isLoaded();
 135         downloadAndVerifyCsarPackageAfterAddProperty(componentPage);
 136     }
 137
 138     @Test(dependsOnMethods = "createBaseService")
 139     public void addOutputsToVF_test() throws UnzipException, IOException {
 140         homePage.isLoaded();
 141         final ComponentPage resourceCreatePage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName());
 142         resourceCreatePage.isLoaded();
 143
 144         final AttributesOutputsPage attributesOutputsPage = resourceCreatePage.goToAttributesOutputs();
 145         attributesOutputsPage.isLoaded();
 146
 147         final ComponentInstance createdComponentInstance = addNodeToCompositionFlow.getCreatedComponentInstance()
 148             .orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a ComponentInstance"));
 149
 150         attributesOutputsPage.clickOnAttributeNavigation(createdComponentInstance.getName());
 151         assertTrue(attributesOutputsPage.isAttributePresent("attr_1"));
 152         attributesOutputsPage.declareOutput("attr_1");
 153         attributesOutputsPage.clickOnOutputsTab();
 154         assertTrue(attributesOutputsPage.isOutputPresent("attr_1"));
 155
 156         attributesOutputsPage.clickOnAttributesTab();
 157         assertTrue(attributesOutputsPage.isAttributePresent("attr_2"));
 158         attributesOutputsPage.declareOutput("attr_2");
 159         attributesOutputsPage.clickOnOutputsTab();
 160         assertTrue(attributesOutputsPage.isOutputPresent("attr_2"));
 161
 162         attributesOutputsPage.clickOnAttributesTab();
 163         assertTrue(attributesOutputsPage.isAttributePresent("attr_3"));
 164         attributesOutputsPage.declareOutput("attr_3");
 165         attributesOutputsPage.clickOnOutputsTab();
 166         assertTrue(attributesOutputsPage.isOutputPresent("attr_3"));
 167
 168         attributesOutputsPage.deleteOutput(createdComponentInstance.getName() + "_attr_2");
 169         attributesOutputsPage.clickOnAttributesTab();
 170         assertTrue(attributesOutputsPage.isAttributePresent("attr_2"));
 171         attributesOutputsPage.clickOnOutputsTab();
 172         assertTrue(attributesOutputsPage.isOutputDeleted("attr_2"));
 173
 174         attributesOutputsPage.clickOnAttributesTab();
 175         ExtentTestActions.addScreenshot(Status.INFO, "AttributesTab", "The Attribute's list : ");
 176
 177         attributesOutputsPage.clickOnOutputsTab();
 178         ExtentTestActions.addScreenshot(Status.INFO, "OutputsTab", "The Output's list : ");
 179
 180         attributesOutputsPage.certifyComponent();
 181         attributesOutputsPage.isLoaded();
 182
 183         Map<String, Object> yamlObject = downloadToscaArtifact(attributesOutputsPage);
 184         checkMetadata(yamlObject, vfResourceCreateData);
 185         checkTopologyTemplate(yamlObject);
 186
 187     }
 188
 189     private void checkMetadata(final Map<String, Object> map, final ResourceCreateData createdData) {
 190         final Map<String, Object> metadata = getMapEntry(map, "metadata");
 191
 192         assertEquals(createdData.getName(), metadata.get("name"));
 193         assertEquals(createdData.getDescription(), metadata.get("description"));
 194         assertEquals("Generic", metadata.get("category"));
 195         assertThat((String) metadata.get("type"), not(emptyString()));
 196         assertEquals(createdData.getCategory(), metadata.get("subcategory"));
 197         assertEquals(createdData.getVendorName(), metadata.get("resourceVendor"));
 198         assertEquals(createdData.getVendorRelease(), metadata.get("resourceVendorRelease"));
 199         assertEquals(createdData.getVendorModelNumber(), metadata.get("reourceVendorModelNumber"));
 200     }
 201
 202     private void checkTopologyTemplate(final Map<String, Object> map) {
 203         final Map<String, Object> mapEntry = getMapEntry(map, "topology_template");
 204         assertNotNull(mapEntry);
 205
 206         final Map<String, Object> inputs = getMapEntry(mapEntry, "inputs");
 207         assertThat(inputs, not(anEmptyMap()));
 208
 209         final Map<String, Object> outputs = getMapEntry(mapEntry, "outputs");
 210         assertThat(outputs, not(anEmptyMap()));
 211         assertEquals(2, outputs.keySet().stream().filter(s -> (s.contains("_attr_1") || s.contains("_attr_3")) && !s.contains("_attr_2")).count());
 212
 213         final Map<String, Object> nodeTemplates = getMapEntry(mapEntry, "node_templates");
 214         assertThat(nodeTemplates, not(anEmptyMap()));
 215
 216         final Map<String, Object> substitutionMappings = getMapEntry(mapEntry, "substitution_mappings");
 217         assertThat(substitutionMappings, not(anEmptyMap()));
 218
 219         final Map<String, Object> attributes = getMapEntry(substitutionMappings, "attributes");
 220         assertThat(attributes, not(anEmptyMap()));
 221         assertEquals(2, attributes.keySet().stream().filter(s -> (s.contains("_attr_1") || s.contains("_attr_3")) && !s.contains("_attr_2")).count());
 222
 223     }
 224
 225     private Map<String, Object> downloadToscaArtifact(final ComponentPage resourceCreatePage) throws UnzipException {
 226         final DownloadCsarArtifactFlow downloadCsarArtifactFlow = downloadToscaCsar(resourceCreatePage);
 227         final ToscaArtifactsPage toscaArtifactsPage = downloadCsarArtifactFlow.getLandedPage()
 228             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ToscaArtifactsPage"));
 229
 230         assertThat("No artifact download was found", toscaArtifactsPage.getDownloadedArtifactList(), not(empty()));
 231         final String downloadedCsarName = toscaArtifactsPage.getDownloadedArtifactList().get(0);
 232         final String downloadFolderPath = getConfig().getDownloadAutomationFolder();
 233         final Map<String, byte[]> filesFromZip = FileHandling.getFilesFromZip(downloadFolderPath, downloadedCsarName);
 234         final Optional<String> resourceEntryOpt = filesFromZip.keySet().stream()
 235             .filter(s -> s.equals("Definitions/" + downloadedCsarName.replace("-csar.csar", "-template.yml")))
 236             .findFirst();
 237         if (resourceEntryOpt.isEmpty()) {
 238             fail("Could not find the resource package in Definitions");
 239         }
 240         return loadYamlObject(filesFromZip.get(resourceEntryOpt.get()));
 241     }
 242
 243     private CreateVfFlow createVF() {
 244         final ResourceCreateData vfCreateData = createVfFormData();
 245         final CreateVfFlow createVfFlow = new CreateVfFlow(webDriver, vfCreateData);
 246         createVfFlow.run(homePage);
 247         return createVfFlow;
 248     }
 249
 250     private ResourceCreateData createVfFormData() {
 251         vfResourceCreateData = new ResourceCreateData();
 252         vfResourceCreateData.setRandomName(ElementFactory.getResourcePrefix() + "-VF");
 253         vfResourceCreateData.setCategory(ResourceCategoryEnum.GENERIC_ABSTRACT.getSubCategory());
 254         vfResourceCreateData.setTagList(Arrays.asList(vfResourceCreateData.getName(), "createVF"));
 255         vfResourceCreateData.setDescription("aDescription");
 256         vfResourceCreateData.setVendorName("EST");
 257         vfResourceCreateData.setVendorRelease("4.1.1");
 258         vfResourceCreateData.setVendorModelNumber("0001");
 259         return vfResourceCreateData;
 260     }
 261
 262     private CreateVfcFlow createVFC(final String vfcFullFilename, final String resourceName) {
 263         final ResourceCreateData vfcCreateData = createVfcFormData(resourceName);
 264         final CreateVfcFlow createVfcFlow = new CreateVfcFlow(webDriver, vfcCreateData, vfcFullFilename);
 265         createVfcFlow.run(homePage);
 266         ExtentTestActions.takeScreenshot(Status.INFO, "vfc-created", String.format("VFC '%s' was created", resourceName));
 267         assertThat(vfcs, notNullValue());
 268         vfcs.add(vfcCreateData);
 269         return createVfcFlow;
 270     }
 271
 272     private ResourceCreateData createVfcFormData(final String resourceName) {
 273         final ResourceCreateData vfcCreateData = new ResourceCreateData();
 274         vfcCreateData.setRandomName(resourceName);
 275         vfcCreateData.setCategory(ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS.getSubCategory());
 276         vfcCreateData.setTagList(Arrays.asList(vfcCreateData.getName(), "importVFC"));
 277         vfcCreateData.setDescription("aDescription");
 278         vfcCreateData.setVendorName("EST");
 279         vfcCreateData.setVendorRelease("4.1.1");
 280         vfcCreateData.setVendorModelNumber("0001");
 281         return vfcCreateData;
 282     }
 283
 284     private AddNodeToCompositionFlow addNodeToCompositionAndCreateRelationship(final CreateVfFlow createVfFlow) {
 285         final ResourceCreatePage resourceCreatePage = createVfFlow.getLandedPage()
 286             .orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a ResourceCreatePage"));
 287         resourceCreatePage.isLoaded();
 288         assertThat(vfcs, hasSize(2));
 289         final ComponentData parentComponent = new ComponentData();
 290         parentComponent.setName(vfResourceCreateData.getName());
 291         parentComponent.setVersion("0.1");
 292         parentComponent.setComponentType(ComponentType.RESOURCE);
 293
 294         // Adds networkFunction to VF composition
 295         final ComponentData networkFunction = new ComponentData();
 296         networkFunction.setName(vfcs.get(0).getName());
 297         networkFunction.setVersion("1.0");
 298         networkFunction.setComponentType(ComponentType.RESOURCE);
 299         CompositionPage compositionPage = resourceCreatePage.goToComposition();
 300         compositionPage.isLoaded();
 301         AddNodeToCompositionFlow addNodeToCompositionFlow = addNodeToComposition(parentComponent, networkFunction, compositionPage);
 302         networkFunctionInstance = addNodeToCompositionFlow.getCreatedComponentInstance()
 303             .orElseThrow(() -> new UiTestFlowRuntimeException("Could not get the created component instance"));
 304
 305         // Adds networkService to VF composition
 306         final ComponentData networkService = new ComponentData();
 307         networkService.setName(vfcs.get(1).getName());
 308         networkService.setVersion("1.0");
 309         networkService.setComponentType(ComponentType.RESOURCE);
 310         addNodeToCompositionFlow = addNodeToComposition(parentComponent, networkService, compositionPage);
 311         networkServiceInstance = addNodeToCompositionFlow.getCreatedComponentInstance()
 312             .orElseThrow(() -> new UiTestFlowRuntimeException("Could not get the created component instance"));
 313
 314         // Creates a dependsOn relationship from networkServiceInstance to networkFunctionInstance
 315         createRelationship(compositionPage, networkFunctionInstance.getName(), "tosca.capabilities.Node",
 316             networkServiceInstance.getName(), "tosca.capabilities.Node");
 317
 318         return addNodeToCompositionFlow;
 319     }
 320
 321     public AddNodeToCompositionFlow addNodeToComposition(final ComponentData parentComponent,
 322                                                          final ComponentData resourceToAdd,
 323                                                          CompositionPage compositionPage) {
 324         final AddNodeToCompositionFlow addNodeToCompositionFlow = new AddNodeToCompositionFlow(webDriver, parentComponent, resourceToAdd);
 325         compositionPage = (CompositionPage) addNodeToCompositionFlow.run(compositionPage)
 326             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected CompositionPage"));
 327         compositionPage.isLoaded();
 328         ExtentTestActions.takeScreenshot(Status.INFO, "node-added-to-composition",
 329             String.format("Resource '%s' was added to composition", resourceToAdd.getName()));
 330         return addNodeToCompositionFlow;
 331     }
 332
 333     /**
 334      * Creates a DependsOn relationship between the imported VFCs
 335      * @param compositionPage Composition Page
 336      * @param fromComponentInstanceName VFC - Network Function
 337      * @param fromCapability Node Capability
 338      * @param toComponentInstanceName  VFC - Network Service
 339      * @param toRequirement Node Requirement
 340      */
 341     private void createRelationship(final CompositionPage compositionPage, final String fromComponentInstanceName,
 342                                     final String fromCapability, final String toComponentInstanceName, final String toRequirement) {
 343         final RelationshipInformation relationshipInformation =
 344             new RelationshipInformation(fromComponentInstanceName, fromCapability, toComponentInstanceName, toRequirement);
 345         CreateRelationshipFlow createRelationshipFlow = new CreateRelationshipFlow(webDriver, relationshipInformation);
 346         createRelationshipFlow.run(compositionPage).orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a CompositionPage instance"));
 347         ExtentTestActions.takeScreenshot(Status.INFO, "relationship",
 348             String.format("Relationship from networkFunctionInstance '%s' to networkServiceInstanceResource '%s' was created",
 349                 fromComponentInstanceName, toComponentInstanceName));
 350     }
 351
 352     /**
 353      * Adds a property to the base service
 354      * @param propertyMap map of properties to be added
 355      */
 356     private void addProperty(final Map<String, String> propertyMap) {
 357         componentPage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName());
 358         componentPage.isLoaded();
 359         final AddComponentPropertyFlow addComponentPropertyFlow = new AddComponentPropertyFlow(webDriver, propertyMap);
 360         addComponentPropertyFlow.run(componentPage.goToPropertiesAssignment());
 361     }
 362
 363     /**
 364      * Edits a property to add a value
 365      * @param propertyMap map of properties to be edited
 366      */
 367     private ComponentPage addValueToProperty(final Map<String, Object> propertyMap) {
 368         final EditComponentPropertiesFlow editComponentPropertiesFlow = new EditComponentPropertiesFlow(webDriver, propertyMap);
 369         return editComponentPropertiesFlow.run().orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected return ComponentPage"));
 370     }
 371
 372     /**
 373      * Downloads and verifies the generated tosca templates.
 374      * @param componentPage the component page
 375      * @throws UnzipException
 376      */
 377     private void downloadAndVerifyCsarPackageAfterBaseServiceCreation(final ComponentPage componentPage) throws UnzipException {
 378         checkCsarPackage(downloadCsarPackage(componentPage));
 379     }
 380
 381     /**
 382      * Downloads and verifies if the generated Tosca template contains the expected properties.
 383      * @throws UnzipException
 384      * @param componentPage
 385      */
 386     private void downloadAndVerifyCsarPackageAfterAddProperty(final ComponentPage componentPage) throws UnzipException {
 387         verifyPropertiesOnGeneratedTemplate(downloadCsarPackage(componentPage));
 388     }
 389
 390     private String downloadCsarPackage(final ComponentPage componentPage) {
 391         final DownloadCsarArtifactFlow downloadCsarArtifactFlow = downloadToscaCsar(componentPage);
 392         final ToscaArtifactsPage toscaArtifactsPage = downloadCsarArtifactFlow.getLandedPage()
 393             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ToscaArtifactsPage"));
 394         assertThat("No artifact download was found", toscaArtifactsPage.getDownloadedArtifactList(), not(empty()));
 395         return toscaArtifactsPage.getDownloadedArtifactList().get(0);
 396     }
 397
 398     /**
 399      * Downloads the generated CSAR package.
 400      * @param componentPage the component page
 401      * @return the Downloaded Tosca CSAR file
 402      */
 403     private DownloadCsarArtifactFlow downloadToscaCsar(final ComponentPage componentPage) {
 404         final DownloadCsarArtifactFlow downloadCsarArtifactFlow = new DownloadCsarArtifactFlow(webDriver);
 405         downloadCsarArtifactFlow.setWaitBeforeGetTheFile(5L);
 406         downloadCsarArtifactFlow.run(componentPage);
 407         return downloadCsarArtifactFlow;
 408     }
 409
 410     /**
 411      * Verifies if the generated Tosca template contains the expected properties.
 412      * @param downloadedCsarName the downloaded csar file name
 413      * @throws UnzipException
 414      */
 415     private void verifyPropertiesOnGeneratedTemplate(final String downloadedCsarName) throws UnzipException {
 416         final Map<String, byte[]> filesFromZip = extractFilesFromCsar(downloadedCsarName);
 417         final String virtualFunctionName = vfResourceCreateData.getName().replace("-", "").toLowerCase();
 418         final String vfResourceTemplateFile = "Definitions/resource-" + virtualFunctionName + "-template-interface.yml";
 419         final String interfaceTemplateFile = filesFromZip.keySet().stream()
 420             .filter(filename -> filename.equalsIgnoreCase(vfResourceTemplateFile)).findFirst()
 421             .orElseThrow(() -> new UiTestFlowRuntimeException(String.format("Resource template file not found %s", vfResourceTemplateFile)));
 422         final byte[] toscaInterfaceTemplateGenerated = filesFromZip.get(interfaceTemplateFile);
 423         assertThat("The Generated Tosca template should not be null", toscaInterfaceTemplateGenerated, is(notNullValue()));
 424         final Map<String, Object> interfaceTemplateYamlMap = loadYamlObject(toscaInterfaceTemplateGenerated);
 425         final Map<String, Object> nodeTypesYamlMap = getMapEntry(interfaceTemplateYamlMap, "node_types");
 426         assertThat(String.format("'%s' should contain a node_types entry", interfaceTemplateYamlMap), nodeTypesYamlMap, is(notNullValue()));
 427         final Map<String, Object> properties = (Map) nodeTypesYamlMap.values().stream().filter(stringObjectEntry -> stringObjectEntry != null)
 428             .collect(Collectors.toList()).get(0);
 429         final Map<String, Object> propertiesFoundMap = (Map<String, Object>) properties.get("properties");
 430         assertThat(String.format("The generated template file %s should contain all added properties", vfResourceTemplateFile),
 431             propertiesFoundMap.keySet().containsAll(propertiesToBeAddedMap.keySet()), is(true));
 432     }
 433
 434     /**
 435      * Checks if the downloaded Tosca csar includes the node templates for the added VFCs,
 436      * the generated service template declared “tosca_simple_yaml_1_3” as its Tosca version,
 437      * the generated csar contains the node type definitions for the added VFCs in the Definitions directory,
 438      * the interface template contains the relationship declaration
 439      * @param downloadedCsarName download Tosca CSAR filename
 440      * @throws UnzipException
 441      */
 442     private void checkCsarPackage(final String downloadedCsarName) throws UnzipException {
 443         final Map<String, byte[]> filesFromZip = extractFilesFromCsar(downloadedCsarName);
 444         final String virtualFunctionName = vfResourceCreateData.getName().replace("-", "").toLowerCase();
 445         final List<String> expectedDefinitionFolderFileList = getExpectedDefinitionFolderFileList(virtualFunctionName);
 446         final Map<String, byte[]> expectedFilesFromZipMap = filesFromZip.entrySet().parallelStream()
 447             .filter(key -> expectedDefinitionFolderFileList.stream()
 448                 .anyMatch(filename -> filename.equalsIgnoreCase(key.getKey()))).collect(Collectors.toMap(Entry::getKey, Entry::getValue));
 449         final String vfResourceTemplateFile = "Definitions/resource-" + virtualFunctionName + "-template.yml";
 450         final String generatedTemplateFile = expectedFilesFromZipMap.keySet().stream()
 451             .filter(filename -> filename.equalsIgnoreCase(vfResourceTemplateFile)).findFirst()
 452             .orElseThrow(() -> new UiTestFlowRuntimeException(String.format("Resource template file not found %s", vfResourceTemplateFile)));
 453         final byte[] toscaTemplateGenerated = filesFromZip.get(generatedTemplateFile);
 454         assertThat(toscaTemplateGenerated, is(notNullValue()));
 455         verifyGeneratedTemplate(toscaTemplateGenerated, generatedTemplateFile);
 456         verifyNodesRelationship(expectedFilesFromZipMap, virtualFunctionName, filesFromZip);
 457     }
 458
 459     private Map<String, byte[]> extractFilesFromCsar(final String downloadedCsarName) throws UnzipException {
 460         final String downloadFolderPath = getConfig().getDownloadAutomationFolder();
 461         final Map<String, byte[]> filesFromCsar = FileHandling.getFilesFromZip(downloadFolderPath, downloadedCsarName);
 462         return filesFromCsar;
 463     }
 464
 465     private void verifyGeneratedTemplate(final byte[] generatedTemplateData, final String generatedTemplateFile) {
 466         final Map<String, Object> templateYamlMap = loadYamlObject(generatedTemplateData);
 467         final boolean hasToscaDefinitionVersionEntry = templateYamlMap.containsKey("tosca_definitions_version");
 468         assertThat(String.format("'%s' should contain tosca_definitions_version entry", generatedTemplateFile), hasToscaDefinitionVersionEntry,
 469             is(true));
 470         final String toscaVersion = (String) templateYamlMap.get("tosca_definitions_version");
 471         assertThat(String.format("'%s' tosca_definitions_version entry should have tosca_simple_yaml_1_3 value", generatedTemplateFile),
 472             toscaVersion.equalsIgnoreCase("tosca_simple_yaml_1_3"));
 473         final Map<String, Object> topologyTemplateTosca = getMapEntry(templateYamlMap, "topology_template");
 474         assertThat(String.format("'%s' should contain a topology_template entry", generatedTemplateFile), topologyTemplateTosca, is(notNullValue()));
 475         final Map<String, Object> nodeTemplatesTosca = getMapEntry(topologyTemplateTosca, "node_templates");
 476         assertThat(String.format("'%s' should contain a node_templates entry", generatedTemplateFile), nodeTemplatesTosca, is(notNullValue()));
 477         final List<String> nodeTemplateFound = nodeTemplatesTosca.keySet().parallelStream().filter(s -> vfcs.stream()
 478             .anyMatch(vfc -> s.startsWith(vfc.getName()))).collect(Collectors.toList());
 479         assertThat(String.format("'%s' should contain the node type definitions for the added VFCs '%s'", nodeTemplatesTosca, vfcs),
 480             nodeTemplateFound, hasSize(vfcs.size()));
 481     }
 482
 483     private void verifyNodesRelationship(final Map<String, byte[]> expectedFilesFromZipMap, final String virtualFunctionName,
 484                                          final Map<String, byte[]> filesFromZip) {
 485         final String vfResourceTemplateFile = "Definitions/resource-" + virtualFunctionName + "-template-interface.yml";
 486         final String interfaceTemplateFile = expectedFilesFromZipMap.keySet().stream()
 487             .filter(filename -> filename.equalsIgnoreCase(vfResourceTemplateFile)).findFirst()
 488             .orElseThrow(() -> new UiTestFlowRuntimeException(String.format("Resource template file not found %s", vfResourceTemplateFile)));
 489         final byte[] toscaInterfaceTemplateGenerated = filesFromZip.get(interfaceTemplateFile);
 490         assertThat(toscaInterfaceTemplateGenerated, is(notNullValue()));
 491         final Map<String, Object> interfaceTemplateYamlMap = loadYamlObject(toscaInterfaceTemplateGenerated);
 492         final Map<String, Object> nodeTypesYamlMap = getMapEntry(interfaceTemplateYamlMap, "node_types");
 493         assertThat(String.format("'%s' should contain a node_types entry", interfaceTemplateYamlMap), nodeTypesYamlMap, is(notNullValue()));
 494         final String result = Arrays.asList(nodeTypesYamlMap.values()).toString();
 495         assertThat(String.format("'%s' should contain a capabilities entry", nodeTypesYamlMap), result.contains("capabilities"), is(true));
 496         assertThat(String.format("'%s' should contain a requirements entry", nodeTypesYamlMap), result.contains("requirements"), is(true));
 497         assertThat(String.format("'%s' should contain a relationship entry", nodeTypesYamlMap), result.contains("relationship"), is(true));
 498         assertThat(String.format("'%s' should contain a DependsOn relationship value", nodeTypesYamlMap),
 499             result.contains("tosca.relationships.DependsOn"), is(true));
 500     }
 501
 502     private List<String> getExpectedDefinitionFolderFileList(final String vfResourceName) {
 503         final List<String> expectedDefinitionFolderFileList = new ArrayList<>();
 504         vfcs.forEach(vfc -> expectedDefinitionFolderFileList.add("Definitions/resource-" + vfc.getName() + "-template.yml"));
 505         expectedDefinitionFolderFileList.add("Definitions/resource-" + vfResourceName + "-template.yml");
 506         expectedDefinitionFolderFileList.add("Definitions/resource-" + vfResourceName + "-template-interface.yml");
 507         return expectedDefinitionFolderFileList;
 508     }
 509
 510     private Map<String, Object> getMapEntry(final Map<String, Object> yamlObj, final String entryName) {
 511         try {
 512             return (Map<String, Object>) yamlObj.get(entryName);
 513         } catch (final Exception e) {
 514             final String errorMsg = String.format("Could not get the '%s' entry.", entryName);
 515             LOGGER.error(errorMsg, e);
 516             fail(errorMsg + "Error message: " + e.getMessage());
 517         }
 518         return null;
 519     }
 520
 521     private Map<String, Object> loadYamlObject(final byte[] definitionYamlFile) {
 522         return new Yaml().load(new String(definitionYamlFile));
 523     }
 524
 525     private Map<String, String> loadPropertiesToAdd() {
 526         final Map<String, String> propertyMap = new HashMap<>();
 527         propertyMap.put("property1", "string");
 528         propertyMap.put("property2", "integer");
 529         propertyMap.put("property3", "boolean");
 530         propertyMap.put("property4", "list");
 531         propertyMap.put("property5", "map");
 532         propertyMap.put("property6", "scalar-unit.size");
 533         return propertyMap;
 534     }
 535
 536     private Map<String, Object> loadPropertiesToEdit() {
 537         final Map<String, Object> propertyMap = new HashMap<>();
 538         propertyMap.put("property1", "Integration Test");
 539         propertyMap.put("property2", 100);
 540         propertyMap.put("property3", Boolean.TRUE);
 541         propertyMap.put("property4", Arrays.asList("PropListV1", "PropListV2", "PropListV3"));
 542         final Map<String, String> stringMap = new HashMap<>();
 543         stringMap.put("PropMapKey1", "PropMapValue1");
 544         stringMap.put("PropMapKey2", "PropMapValue2");
 545         stringMap.put("PropMapKey3", "PropMapValue3");
 546         propertyMap.put("property5", stringMap);
 547         propertyMap.put("property6", 500);
 548         return propertyMap;
 549     }
 550 }