/* * ============LICENSE_START======================================================= * Copyright (C) 2021 Nordix Foundation * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * SPDX-License-Identifier: Apache-2.0 * ============LICENSE_END========================================================= */ package org.onap.sdc.frontend.ci.tests.execute.sanity; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.anEmptyMap; import static org.hamcrest.Matchers.empty; import static org.hamcrest.Matchers.emptyString; import static org.hamcrest.Matchers.equalToIgnoringCase; import static org.hamcrest.Matchers.hasSize; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.not; import static org.hamcrest.Matchers.notNullValue; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Optional; import java.util.stream.Collectors; import org.onap.sdc.backend.ci.tests.data.providers.OnboardingDataProviders; import org.onap.sdc.backend.ci.tests.datatypes.enums.ComponentType; import org.onap.sdc.backend.ci.tests.datatypes.enums.ResourceCategoryEnum; import org.onap.sdc.backend.ci.tests.utils.general.ElementFactory; import org.onap.sdc.frontend.ci.tests.datatypes.ComponentData; import org.onap.sdc.frontend.ci.tests.datatypes.DirectiveType; import org.onap.sdc.frontend.ci.tests.datatypes.LogicalOperator; import org.onap.sdc.frontend.ci.tests.datatypes.ResourceCreateData; import org.onap.sdc.frontend.ci.tests.datatypes.ServiceDependencyProperty; import org.onap.sdc.frontend.ci.tests.datatypes.composition.RelationshipInformation; import org.onap.sdc.frontend.ci.tests.exception.UnzipException; import org.onap.sdc.frontend.ci.tests.execute.setup.DriverFactory; import org.onap.sdc.frontend.ci.tests.execute.setup.ExtentTestActions; import org.onap.sdc.frontend.ci.tests.execute.setup.SetupCDTest; import org.onap.sdc.frontend.ci.tests.flow.AddComponentInputFlow; import org.onap.sdc.frontend.ci.tests.flow.AddComponentPropertyFlow; import org.onap.sdc.frontend.ci.tests.flow.AddNodeToCompositionFlow; import org.onap.sdc.frontend.ci.tests.flow.CreateDirectiveNodeFilterFlow; import org.onap.sdc.frontend.ci.tests.flow.CreateSubstitutionFilterFlow; import org.onap.sdc.frontend.ci.tests.flow.CreateVfFlow; import org.onap.sdc.frontend.ci.tests.flow.CreateVfcFlow; import org.onap.sdc.frontend.ci.tests.flow.DownloadToscaTemplateFlow; import org.onap.sdc.frontend.ci.tests.flow.DownloadCsarArtifactFlow; import org.onap.sdc.frontend.ci.tests.flow.EditComponentPropertiesFlow; import org.onap.sdc.frontend.ci.tests.flow.composition.CreateRelationshipFlow; import org.onap.sdc.frontend.ci.tests.flow.exception.UiTestFlowRuntimeException; import org.onap.sdc.frontend.ci.tests.pages.AttributesOutputsPage; import org.onap.sdc.frontend.ci.tests.pages.ComponentPage; import org.onap.sdc.frontend.ci.tests.pages.ResourceCreatePage; import org.onap.sdc.frontend.ci.tests.pages.ResourcePropertiesAssignmentPage; import org.onap.sdc.frontend.ci.tests.pages.ResourcePropertiesPage; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionDetailSideBarComponent; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionDetailSideBarComponent.CompositionDetailTabName; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionInformationTab; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.InterfaceDefinitionOperationsModal; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionInterfaceOperationsTab; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.CompositionPage; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.InterfaceDefinitionOperationsModal.InterfaceOperationsData.InputData; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.RelationshipWizardInterfaceOperation.InterfaceOperationsData; import org.onap.sdc.frontend.ci.tests.pages.component.workspace.ToscaArtifactsPage; import org.onap.sdc.frontend.ci.tests.pages.home.HomePage; import org.onap.sdc.frontend.ci.tests.utilities.FileHandling; import org.openecomp.sdc.be.model.ComponentInstance; import org.openqa.selenium.WebDriver; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; import org.yaml.snakeyaml.Yaml; import com.aventstack.extentreports.Status; public class ServiceTemplateDesignUiTests extends SetupCDTest { private static final Logger LOGGER = LoggerFactory.getLogger(ServiceTemplateDesignUiTests.class); private WebDriver webDriver; private HomePage homePage; private List vfcs = new ArrayList<>(); private ResourceCreateData vfResourceCreateData; private ComponentInstance networkFunctionInstance; private ComponentInstance networkServiceInstance; private AddNodeToCompositionFlow addNodeToCompositionFlow; private ComponentPage componentPage; private Map propertiesToBeAddedMap; private ResourceCreatePage resourceCreatePage; private Map inputsToBeAddedMap; private final List substitutionFilterProperties = new ArrayList<>(); private final String interfaceName = "Standard"; private final String interfaceOperationName = "create"; private final String implementationName = "IntegrationTest"; private final String inputName = "InputName1"; private final String inputValue = "InputValue1"; @BeforeMethod public void init() { webDriver = DriverFactory.getDriver(); homePage = new HomePage(webDriver); } @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "vfcList") public void importAndCertifyVfc(final String rootFolder, final String vfcFilename) { setLog(vfcFilename); final String resourceName = ElementFactory.addRandomSuffixToName(ElementFactory.getResourcePrefix()); final CreateVfcFlow createVfcFlow = createVFC(rootFolder + vfcFilename, resourceName); vfcs.stream().filter(vfc -> vfc.getName().startsWith(resourceName)).findFirst().orElseThrow( () -> new UiTestFlowRuntimeException(String.format("VFCs List should contain a VFC with the expected name %s", resourceName))); final ResourceCreatePage vfcResourceCreatePage = createVfcFlow.getLandedPage() .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ResourceCreatePage")); vfcResourceCreatePage.isLoaded(); vfcResourceCreatePage.certifyComponent(); ExtentTestActions.takeScreenshot(Status.INFO, "vfc-certified", String.format("VFC '%s' was certified", resourceName)); } @Test(dependsOnMethods = "importAndCertifyVfc") public void createBaseService() { final CreateVfFlow createVfFlow = createVF(); resourceCreatePage = createVfFlow.getLandedPage() .orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a ResourceCreatePage")); resourceCreatePage.isLoaded(); } @Test(dependsOnMethods = "createBaseService") public void addComponentProperty() throws UnzipException { propertiesToBeAddedMap = loadPropertiesToAdd(); addProperty(propertiesToBeAddedMap); componentPage = addValueToProperty(loadPropertiesToEdit()); componentPage.isLoaded(); downloadAndVerifyCsarPackageAfterAddProperty(componentPage); } @Test(dependsOnMethods = "createBaseService") public void addRelationshipTemplate() throws UnzipException { homePage.isLoaded(); resourceCreatePage = (ResourceCreatePage) homePage.clickOnComponent(vfResourceCreateData.getName()); resourceCreatePage.isLoaded(); addNodeToCompositionFlow = addNodeToCompositionAndCreateRelationship(); final CompositionPage compositionPage = addNodeToCompositionFlow.getLandedPage() .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected return CompositionPage")); compositionPage.isLoaded(); componentPage = compositionPage.goToGeneral(); componentPage.isLoaded(); downloadAndVerifyCsarPackage(componentPage); } @Test(dependsOnMethods = "addRelationshipTemplate") public void createMetadataForServiceProperty() throws Exception { homePage.isLoaded(); componentPage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName()); componentPage.isLoaded(); final ResourcePropertiesAssignmentPage propertiesAssignmentPage = componentPage.goToPropertiesAssignment(); propertiesAssignmentPage.isLoaded(); propertiesAssignmentPage.selectInputTab(); final var propertyName = propertiesAssignmentPage.getInputPropertyNames().get(0); final var key = "Key"; final var value = "Test"; propertiesAssignmentPage.setInputPropertyMetadata(propertyName, key, value); final var topologyTemplate = getMapEntry(downloadToscaTemplate(), "topology_template"); final var inputs = getMapEntry(topologyTemplate, "inputs"); final var serviceProperty = getMapEntry(inputs, propertyName); final var servicePropertyMetadata = getMapEntry(serviceProperty, "metadata"); assertNotNull(servicePropertyMetadata, String.format("Metadata not found for property %s", propertyName)); assertEquals(servicePropertyMetadata.get(key), value, "Created service property metadata has invalid value"); } @Test(dependsOnMethods = "addRelationshipTemplate") public void addOutputsToVF_test() throws UnzipException, IOException { homePage.isLoaded(); final ComponentPage resourceCreatePage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName()); resourceCreatePage.isLoaded(); final AttributesOutputsPage attributesOutputsPage = resourceCreatePage.goToAttributesOutputs(); attributesOutputsPage.isLoaded(); final ComponentInstance createdComponentInstance = addNodeToCompositionFlow.getCreatedComponentInstance() .orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a ComponentInstance")); attributesOutputsPage.clickOnAttributeNavigation(createdComponentInstance.getName()); assertTrue(attributesOutputsPage.isAttributePresent("attr_1")); attributesOutputsPage.declareOutput("attr_1"); attributesOutputsPage.clickOnOutputsTab(); assertTrue(attributesOutputsPage.isOutputPresent("attr_1")); attributesOutputsPage.clickOnAttributesTab(); assertTrue(attributesOutputsPage.isAttributePresent("attr_2")); attributesOutputsPage.declareOutput("attr_2"); attributesOutputsPage.clickOnOutputsTab(); assertTrue(attributesOutputsPage.isOutputPresent("attr_2")); attributesOutputsPage.clickOnAttributesTab(); assertTrue(attributesOutputsPage.isAttributePresent("attr_3")); attributesOutputsPage.declareOutput("attr_3"); attributesOutputsPage.clickOnOutputsTab(); assertTrue(attributesOutputsPage.isOutputPresent("attr_3")); attributesOutputsPage.deleteOutput(createdComponentInstance.getName() + "_attr_2"); attributesOutputsPage.clickOnAttributesTab(); assertTrue(attributesOutputsPage.isAttributePresent("attr_2")); attributesOutputsPage.clickOnOutputsTab(); assertTrue(attributesOutputsPage.isOutputDeleted("attr_2")); attributesOutputsPage.clickOnAttributesTab(); ExtentTestActions.addScreenshot(Status.INFO, "AttributesTab", "The Attribute's list : "); attributesOutputsPage.clickOnOutputsTab(); ExtentTestActions.addScreenshot(Status.INFO, "OutputsTab", "The Output's list : "); Map yamlObject = downloadToscaArtifact(attributesOutputsPage); checkMetadata(yamlObject, vfResourceCreateData); checkTopologyTemplate(yamlObject); } @Test(dependsOnMethods = "addRelationshipTemplate") public void updateInterfaceOperation() throws Exception { homePage.isLoaded(); componentPage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName()); componentPage.isLoaded(); final CompositionPage compositionPage = componentPage.goToComposition(); compositionPage.isLoaded(); ExtentTestActions.addScreenshot(Status.INFO, "select-VFC-node", "Selecting Node on composition"); compositionPage.selectNode(vfcs.get(1).getName()); final List inputList = List.of( new InputData("My_IT_InputName", "string", "My_IT_InputValue") ); final InterfaceDefinitionOperationsModal.InterfaceOperationsData interfaceOperationsData = new InterfaceDefinitionOperationsModal.InterfaceOperationsData("IT for updating an Interface Operation", "MyIntegrationTestImplementationName", inputList); updateInterfaceOperation(compositionPage, interfaceOperationsData); componentPage = compositionPage.goToGeneral(); componentPage.isLoaded(); verifyToscaTemplateHasUpdatedInterfaceOperation(downloadToscaTemplate(), interfaceOperationsData); } @Test(dependsOnMethods = "addComponentProperty") public void createSubstitutionFilter() throws Exception { componentPage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName()); componentPage.isLoaded(); loadSubstitutionFilterProperties(); final CompositionPage compositionPage = componentPage.goToComposition(); compositionPage.isLoaded(); substitutionFilterProperties.forEach(substitutionFilterProperty -> { final CreateSubstitutionFilterFlow createSubstitutionFilterFlow = new CreateSubstitutionFilterFlow(webDriver, substitutionFilterProperty); createSubstitutionFilterFlow.run(compositionPage); }); componentPage = compositionPage.goToGeneral(); componentPage.isLoaded(); verifyToscaTemplateHasSubstitutionFilter(downloadToscaTemplate()); } @Test(dependsOnMethods = "createBaseService") public void createDirectiveNodeFilterTest() throws Exception { final ResourceCreateData vfcResourceCreateData = vfcs.get(1); final String vfcNameInComposition = vfcResourceCreateData.getName().concat(" 0"); final String value = "Test"; final LogicalOperator operator = LogicalOperator.EQUALS; homePage.isLoaded(); componentPage = (ComponentPage) homePage.clickOnComponent(vfcResourceCreateData.getName()); componentPage.isLoaded(); final ResourcePropertiesPage vfcPropertiesPage = componentPage.goToProperties(); vfcPropertiesPage.isLoaded(); final Map propertyNamesAndTypes = vfcPropertiesPage.getPropertyNamesAndTypes(); final List propertyNames = propertyNamesAndTypes.keySet().stream().collect(Collectors.toList()); final ServiceDependencyProperty serviceDependencyProperty = new ServiceDependencyProperty(propertyNames.get(0), propertyNamesAndTypes.get(propertyNames.get(0)), value, operator); homePage.getTopNavComponent().clickOnHome(); homePage.isLoaded(); homePage.clickOnComponent(vfResourceCreateData.getName()); componentPage.isLoaded(); final CompositionPage compositionPage = componentPage.goToComposition(); compositionPage.isLoaded(); compositionPage.selectNode(vfcNameInComposition); final CreateDirectiveNodeFilterFlow createDirectiveNodeFilterFlow = new CreateDirectiveNodeFilterFlow(webDriver, 2, serviceDependencyProperty); createDirectiveNodeFilterFlow.run(componentPage); verifyAvailableDirectiveTypes(createDirectiveNodeFilterFlow.getDirectiveOptions()); verifyAvailablePropertyNames(propertyNames, createDirectiveNodeFilterFlow.getPropertyOptions()); componentPage = compositionPage.goToGeneral(); componentPage.isLoaded(); final Map yaml = downloadToscaTemplate(); verifyToscaTemplateHasDirectiveNodeFilter(yaml, serviceDependencyProperty, vfcNameInComposition); } @Test(dependsOnMethods = "addComponentProperty") public void declareInputFromProperties() throws Exception { componentPage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName()); componentPage.isLoaded(); ResourcePropertiesAssignmentPage propertiesAssignmentPage = componentPage.goToPropertiesAssignment(); propertiesAssignmentPage.isLoaded(); declareInputToBaseService(propertiesAssignmentPage, "property1"); declareInputToInstanceProperties(propertiesAssignmentPage, "resourceSubtype"); verifyToscaTemplateHasDeclareInput(downloadToscaTemplate()); } @Test(dependsOnMethods = "createBaseService") public void addComponentInputs() throws Exception { inputsToBeAddedMap = loadInputsToAdd(); addInput(inputsToBeAddedMap); verifyToscaTemplateAddInput(downloadToscaTemplate()); } private void checkMetadata(final Map map, final ResourceCreateData createdData) { final Map metadata = getMapEntry(map, "metadata"); assertEquals(createdData.getName(), metadata.get("name")); assertEquals(createdData.getDescription(), metadata.get("description")); assertEquals("Generic", metadata.get("category")); assertThat((String) metadata.get("type"), not(emptyString())); assertEquals(createdData.getCategory(), metadata.get("subcategory")); assertEquals(createdData.getVendorName(), metadata.get("resourceVendor")); assertEquals(createdData.getVendorRelease(), metadata.get("resourceVendorRelease")); assertEquals(createdData.getVendorModelNumber(), metadata.get("reourceVendorModelNumber")); } private void checkTopologyTemplate(final Map map) { final Map mapEntry = getMapEntry(map, "topology_template"); assertNotNull(mapEntry); final Map inputs = getMapEntry(mapEntry, "inputs"); assertThat(inputs, not(anEmptyMap())); final Map outputs = getMapEntry(mapEntry, "outputs"); assertThat(outputs, not(anEmptyMap())); assertEquals(2, outputs.keySet().stream().filter(s -> (s.contains("_attr_1") || s.contains("_attr_3")) && !s.contains("_attr_2")).count()); final Map nodeTemplates = getMapEntry(mapEntry, "node_templates"); assertThat(nodeTemplates, not(anEmptyMap())); final Map substitutionMappings = getMapEntry(mapEntry, "substitution_mappings"); assertThat(substitutionMappings, not(anEmptyMap())); final Map attributes = getMapEntry(substitutionMappings, "attributes"); assertThat(attributes, not(anEmptyMap())); assertEquals(2, attributes.keySet().stream().filter(s -> (s.contains("_attr_1") || s.contains("_attr_3")) && !s.contains("_attr_2")).count()); } /** * Updates an Interface operation from a selected Node (VFC) * @param compositionPage the composition page * @param interfaceOperationsData the interface definition * @throws IOException */ private void updateInterfaceOperation(final CompositionPage compositionPage, final InterfaceDefinitionOperationsModal.InterfaceOperationsData interfaceOperationsData) throws IOException { final CompositionDetailSideBarComponent detailSideBar = compositionPage.getDetailSideBar(); detailSideBar.isLoaded(); final CompositionInterfaceOperationsTab compositionInterfaceOperationsTab = (CompositionInterfaceOperationsTab) detailSideBar.selectTab(CompositionDetailTabName.INTERFACE_OPERATIONS); compositionInterfaceOperationsTab.isLoaded(); ExtentTestActions.takeScreenshot(Status.INFO, "compositionInterfaceOperationsTab", "Composition Interface Operations Tab loaded"); assertTrue(compositionInterfaceOperationsTab.isOperationPresent(interfaceOperationName)); final InterfaceDefinitionOperationsModal compositionInterfaceOperationsModal = compositionInterfaceOperationsTab .clickOnOperation(interfaceOperationName); compositionInterfaceOperationsModal.isLoaded(); ExtentTestActions.takeScreenshot(Status.INFO, "update-interface-operation-modal", "Loading Interface Operations Modal"); compositionInterfaceOperationsModal.updateInterfaceOperation(interfaceOperationsData); compositionInterfaceOperationsTab.isLoaded(); ExtentTestActions.addScreenshot(Status.INFO, "updated-interface-operation", "The Interface operation from the selected Node was successfully updated"); // Gives time for UI to load the Updated Interface Operation final CompositionInformationTab compositionInformationTab = (CompositionInformationTab) detailSideBar.selectTab(CompositionDetailTabName.INFORMATION); compositionInformationTab.isLoaded(); validateUpdatedInterfaceOperation(detailSideBar, interfaceOperationsData); } /** * Validates if the Updated Interface Operation has the expected values * @param detailSideBar The composition Page * @param interfaceOperationsData The Updated Interface Definition */ private void validateUpdatedInterfaceOperation(final CompositionDetailSideBarComponent detailSideBar, final InterfaceDefinitionOperationsModal.InterfaceOperationsData interfaceOperationsData) { final CompositionInterfaceOperationsTab compositionInterfaceOperationsTab = (CompositionInterfaceOperationsTab) detailSideBar .selectTab(CompositionDetailTabName.INTERFACE_OPERATIONS); compositionInterfaceOperationsTab.isLoaded(); assertTrue(compositionInterfaceOperationsTab.isOperationPresent(interfaceOperationName)); assertTrue(compositionInterfaceOperationsTab.isDescriptionPresent()); final InterfaceDefinitionOperationsModal compositionInterfaceOperationsModal = compositionInterfaceOperationsTab .clickOnOperation(interfaceOperationName); compositionInterfaceOperationsModal.isLoaded(); ExtentTestActions.takeScreenshot(Status.INFO, "validate-updated-interface-operation", "Loading the Interface Operations Modal for validating"); assertThat("The Interface Operation Description should match", interfaceOperationsData.getDescription(), equalToIgnoringCase(compositionInterfaceOperationsModal.getDescription())); assertThat("The Interface Operation Implementation Name should match", interfaceOperationsData.getImplementationName(), equalToIgnoringCase(compositionInterfaceOperationsModal.getImplementationName())); // assertThat("The Interface Operation Input key should match", interfaceOperationsData.getInputName(), // equalToIgnoringCase(compositionInterfaceOperationsModal.getInputName())); // assertThat("The Interface Operation Input Value should match", interfaceOperationsData.getInputValue(), // equalToIgnoringCase(compositionInterfaceOperationsModal.getInputValue())); compositionInterfaceOperationsModal.clickOnCancel(); } private void verifyToscaTemplateHasUpdatedInterfaceOperation(final Map toscaTemplateYaml, final InterfaceDefinitionOperationsModal.InterfaceOperationsData interfaceOperationsData) { assertNotNull(toscaTemplateYaml, "No contents in TOSCA Template"); final Map topologyTemplateTosca = getMapEntry((Map) toscaTemplateYaml, "topology_template"); assertThat("Should contain a topology_template entry", toscaTemplateYaml, is(notNullValue())); final Map nodeTemplatesTosca = getMapEntry(topologyTemplateTosca, "node_templates"); assertThat("Should contain a node_templates entry", nodeTemplatesTosca, is(notNullValue())); final Optional> nodeWithInterfaceOperation = nodeTemplatesTosca.entrySet().stream() .filter(s -> s.getKey().startsWith(vfcs.get(1).getName())).findFirst(); assertThat("Should contain a node (VFC)", nodeWithInterfaceOperation.isPresent(), is(true)); final Map interfacesEntry = (Map) nodeWithInterfaceOperation.get().getValue(); assertThat("The Interfaces Entry should not be empty", interfacesEntry, not(anEmptyMap())); final Map interfaceOperations = (Map) interfacesEntry.get("interfaces"); assertThat("The Interface Entry should have operations", interfaceOperations, not(anEmptyMap())); final Map interfaceNameMap = (Map) interfaceOperations.get(interfaceName); assertThat(String.format("'%s' should contain a Interface Name entry '%s'", interfaceNameMap, interfaceName), interfaceOperations, not(anEmptyMap())); final Map updatedInterfaceOperation = (Map) interfaceNameMap.get(interfaceOperationName); assertThat(String.format("'%s' should contain a Interface Operation Name '%s'", updatedInterfaceOperation, interfaceOperationName), updatedInterfaceOperation, not(anEmptyMap())); assertThat("The Interface Operation Description should match", updatedInterfaceOperation.get("description").equals(interfaceOperationsData.getDescription())); assertThat("The Interface Operation Implementation Name should match", updatedInterfaceOperation.get("implementation").equals(interfaceOperationsData.getImplementationName())); final Map updatedInterfaceOperationInput = (Map) updatedInterfaceOperation.get("inputs"); interfaceOperationsData.getInputList().forEach(inputData -> { assertThat("The Interface Operation Input Key should match", updatedInterfaceOperationInput.containsKey(inputData.getName())); assertThat("The Interface Operation Input Value should match", updatedInterfaceOperationInput.containsValue(inputData.getValue())); }); } private Map downloadToscaArtifact(final ComponentPage resourceCreatePage) throws UnzipException { final DownloadCsarArtifactFlow downloadCsarArtifactFlow = downloadToscaCsar(resourceCreatePage); final ToscaArtifactsPage toscaArtifactsPage = downloadCsarArtifactFlow.getLandedPage() .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ToscaArtifactsPage")); assertThat("No artifact download was found", toscaArtifactsPage.getDownloadedArtifactList(), not(empty())); final String downloadedCsarName = toscaArtifactsPage.getDownloadedArtifactList().get(0); final String downloadFolderPath = getConfig().getDownloadAutomationFolder(); final Map filesFromZip = FileHandling.getFilesFromZip(downloadFolderPath, downloadedCsarName); final Optional resourceEntryOpt = filesFromZip.keySet().stream() .filter(s -> s.equals("Definitions/" + downloadedCsarName.replace("-csar.csar", "-template.yml"))) .findFirst(); if (resourceEntryOpt.isEmpty()) { fail("Could not find the resource package in Definitions"); } return loadYamlObject(filesFromZip.get(resourceEntryOpt.get())); } private void declareInputToBaseService(ResourcePropertiesAssignmentPage propertiesAssignmentPage, String propertyName){ propertiesAssignmentPage.selectProperty(propertyName); propertiesAssignmentPage.clickOnDeclareInput(); propertiesAssignmentPage.clickInputTab(propertyName); propertiesAssignmentPage.isInputPresent(vfResourceCreateData.getName() + "_" + propertyName); } private void declareInputToInstanceProperties(ResourcePropertiesAssignmentPage propertiesAssignmentPage, String propertyName){ propertiesAssignmentPage.selectPropertiesTab(); propertiesAssignmentPage.loadCompositionTab(); propertiesAssignmentPage.loadComponentInstanceProperties(vfcs.get(0).getName().concat(" 0")); propertiesAssignmentPage.selectProperty(propertyName); propertiesAssignmentPage.clickOnDeclareInput(); propertiesAssignmentPage.clickInputTab(propertyName); propertiesAssignmentPage.isInputPresent(vfResourceCreateData.getName() + "_" + vfcs.get(0).getName()); } private CreateVfFlow createVF() { final ResourceCreateData vfCreateData = createVfFormData(); final CreateVfFlow createVfFlow = new CreateVfFlow(webDriver, vfCreateData); createVfFlow.run(homePage); return createVfFlow; } private ResourceCreateData createVfFormData() { vfResourceCreateData = new ResourceCreateData(); vfResourceCreateData.setRandomName(ElementFactory.getResourcePrefix() + "-VF"); vfResourceCreateData.setCategory(ResourceCategoryEnum.GENERIC_ABSTRACT.getSubCategory()); vfResourceCreateData.setTagList(Arrays.asList(vfResourceCreateData.getName(), "createVF")); vfResourceCreateData.setDescription("aDescription"); vfResourceCreateData.setVendorName("EST"); vfResourceCreateData.setVendorRelease("4.1.1"); vfResourceCreateData.setVendorModelNumber("0001"); return vfResourceCreateData; } private CreateVfcFlow createVFC(final String vfcFullFilename, final String resourceName) { final ResourceCreateData vfcCreateData = createVfcFormData(resourceName); final CreateVfcFlow createVfcFlow = new CreateVfcFlow(webDriver, vfcCreateData, vfcFullFilename); createVfcFlow.run(homePage); ExtentTestActions.takeScreenshot(Status.INFO, "vfc-created", String.format("VFC '%s' was created", resourceName)); assertThat(vfcs, notNullValue()); vfcs.add(vfcCreateData); return createVfcFlow; } private ResourceCreateData createVfcFormData(final String resourceName) { final ResourceCreateData vfcCreateData = new ResourceCreateData(); vfcCreateData.setRandomName(resourceName); vfcCreateData.setCategory(ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS.getSubCategory()); vfcCreateData.setTagList(Arrays.asList(vfcCreateData.getName(), "importVFC")); vfcCreateData.setDescription("aDescription"); vfcCreateData.setVendorName("EST"); vfcCreateData.setVendorRelease("4.1.1"); vfcCreateData.setVendorModelNumber("0001"); return vfcCreateData; } private AddNodeToCompositionFlow addNodeToCompositionAndCreateRelationship() { assertThat(vfcs, hasSize(2)); final ComponentData parentComponent = new ComponentData(); parentComponent.setName(vfResourceCreateData.getName()); parentComponent.setVersion("0.1"); parentComponent.setComponentType(ComponentType.RESOURCE); // Adds networkFunction to VF composition final ComponentData networkFunction = new ComponentData(); networkFunction.setName(vfcs.get(0).getName()); networkFunction.setVersion("1.0"); networkFunction.setComponentType(ComponentType.RESOURCE); final CompositionPage compositionPage = resourceCreatePage.goToComposition(); compositionPage.isLoaded(); AddNodeToCompositionFlow addNodeToCompositionFlow = addNodeToComposition(parentComponent, networkFunction, compositionPage); networkFunctionInstance = addNodeToCompositionFlow.getCreatedComponentInstance() .orElseThrow(() -> new UiTestFlowRuntimeException("Could not get the created component instance")); // Adds networkService to VF composition final ComponentData networkService = new ComponentData(); networkService.setName(vfcs.get(1).getName()); networkService.setVersion("1.0"); networkService.setComponentType(ComponentType.RESOURCE); addNodeToCompositionFlow = addNodeToComposition(parentComponent, networkService, compositionPage); networkServiceInstance = addNodeToCompositionFlow.getCreatedComponentInstance() .orElseThrow(() -> new UiTestFlowRuntimeException("Could not get the created component instance")); // Creates a dependsOn relationship from networkServiceInstance to networkFunctionInstance createRelationship(compositionPage, networkFunctionInstance.getName(), "tosca.capabilities.Node", networkServiceInstance.getName(), "tosca.capabilities.Node"); return addNodeToCompositionFlow; } public AddNodeToCompositionFlow addNodeToComposition(final ComponentData parentComponent, final ComponentData resourceToAdd, CompositionPage compositionPage) { final AddNodeToCompositionFlow addNodeToCompositionFlow = new AddNodeToCompositionFlow(webDriver, parentComponent, resourceToAdd); compositionPage = (CompositionPage) addNodeToCompositionFlow.run(compositionPage) .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected CompositionPage")); compositionPage.isLoaded(); ExtentTestActions.takeScreenshot(Status.INFO, "node-added-to-composition", String.format("Resource '%s' was added to composition", resourceToAdd.getName())); return addNodeToCompositionFlow; } /** * Creates a DependsOn relationship between the imported VFCs * @param compositionPage Composition Page * @param fromComponentInstanceName VFC - Network Function * @param fromCapability Node Capability * @param toComponentInstanceName VFC - Network Service * @param toRequirement Node Requirement */ private void createRelationship(final CompositionPage compositionPage, final String fromComponentInstanceName, final String fromCapability, final String toComponentInstanceName, final String toRequirement) { final RelationshipInformation relationshipInformation = new RelationshipInformation(fromComponentInstanceName, fromCapability, toComponentInstanceName, toRequirement); final CreateRelationshipFlow createRelationshipFlow = new CreateRelationshipFlow(webDriver, relationshipInformation, new InterfaceOperationsData(interfaceName, interfaceOperationName, implementationName, inputName, inputValue)); createRelationshipFlow.run(compositionPage).orElseThrow(() -> new UiTestFlowRuntimeException("Expecting a CompositionPage instance")); ExtentTestActions.takeScreenshot(Status.INFO, "relationship", String.format("Relationship from networkFunctionInstance '%s' to networkServiceInstanceResource '%s' was created", fromComponentInstanceName, toComponentInstanceName)); } /** * Adds a property to the base service * @param propertyMap map of properties to be added */ private void addProperty(final Map propertyMap) { componentPage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName()); componentPage.isLoaded(); final AddComponentPropertyFlow addComponentPropertyFlow = new AddComponentPropertyFlow(webDriver, propertyMap); addComponentPropertyFlow.run(componentPage.goToPropertiesAssignment()); } /** * Adds a input to the base service * @param inputMap map of inputs to be added */ private void addInput(final Map inputMap) { componentPage = (ComponentPage) homePage.clickOnComponent(vfResourceCreateData.getName()); componentPage.isLoaded(); final AddComponentInputFlow addComponentInputFlow = new AddComponentInputFlow(webDriver, inputMap); addComponentInputFlow.run(componentPage.goToPropertiesAssignment()); } /** * Edits a property to add a value * @param propertyMap map of properties to be edited */ private ComponentPage addValueToProperty(final Map propertyMap) { final EditComponentPropertiesFlow editComponentPropertiesFlow = new EditComponentPropertiesFlow(webDriver, propertyMap); return editComponentPropertiesFlow.run().orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected return ComponentPage")); } /** * Downloads and verifies the generated tosca templates. * @param componentPage the component page * @throws UnzipException */ private void downloadAndVerifyCsarPackage(final ComponentPage componentPage) throws UnzipException { checkCsarPackage(downloadCsarPackage(componentPage)); } /** * Downloads and verifies if the generated Tosca template contains the expected properties. * @throws UnzipException * @param componentPage */ private void downloadAndVerifyCsarPackageAfterAddProperty(final ComponentPage componentPage) throws UnzipException { verifyPropertiesOnGeneratedTemplate(downloadCsarPackage(componentPage)); } private String downloadCsarPackage(final ComponentPage componentPage) { final DownloadCsarArtifactFlow downloadCsarArtifactFlow = downloadToscaCsar(componentPage); final ToscaArtifactsPage toscaArtifactsPage = downloadCsarArtifactFlow.getLandedPage() .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected ToscaArtifactsPage")); assertThat("No artifact download was found", toscaArtifactsPage.getDownloadedArtifactList(), not(empty())); return toscaArtifactsPage.getDownloadedArtifactList().get(0); } /** * Downloads the generated CSAR package. * @param componentPage the component page * @return the Downloaded Tosca CSAR file */ private DownloadCsarArtifactFlow downloadToscaCsar(final ComponentPage componentPage) { final DownloadCsarArtifactFlow downloadCsarArtifactFlow = new DownloadCsarArtifactFlow(webDriver); downloadCsarArtifactFlow.setWaitBeforeGetTheFile(5L); downloadCsarArtifactFlow.run(componentPage); return downloadCsarArtifactFlow; } /** * Verifies if the generated Tosca template contains the expected properties. * @param downloadedCsarName the downloaded csar file name * @throws UnzipException */ private void verifyPropertiesOnGeneratedTemplate(final String downloadedCsarName) throws UnzipException { final Map filesFromZip = extractFilesFromCsar(downloadedCsarName); final String virtualFunctionName = vfResourceCreateData.getName().replace("-", "").toLowerCase(); final String vfResourceTemplateFile = "Definitions/resource-" + virtualFunctionName + "-template-interface.yml"; final String interfaceTemplateFile = filesFromZip.keySet().stream() .filter(filename -> filename.equalsIgnoreCase(vfResourceTemplateFile)).findFirst() .orElseThrow(() -> new UiTestFlowRuntimeException(String.format("Resource template file not found %s", vfResourceTemplateFile))); final byte[] toscaInterfaceTemplateGenerated = filesFromZip.get(interfaceTemplateFile); assertThat("The Generated Tosca template should not be null", toscaInterfaceTemplateGenerated, is(notNullValue())); final Map interfaceTemplateYamlMap = loadYamlObject(toscaInterfaceTemplateGenerated); final Map nodeTypesYamlMap = getMapEntry(interfaceTemplateYamlMap, "node_types"); assertThat(String.format("'%s' should contain a node_types entry", interfaceTemplateYamlMap), nodeTypesYamlMap, is(notNullValue())); final Map properties = (Map) nodeTypesYamlMap.values().stream().filter(stringObjectEntry -> stringObjectEntry != null) .collect(Collectors.toList()).get(0); final Map propertiesFoundMap = (Map) properties.get("properties"); assertThat(String.format("The generated template file %s should contain all added properties", vfResourceTemplateFile), propertiesFoundMap.keySet().containsAll(propertiesToBeAddedMap.keySet()), is(true)); } /** * Checks if the downloaded Tosca csar includes the node templates for the added VFCs, * the generated service template declared “tosca_simple_yaml_1_3” as its Tosca version, * the generated csar contains the node type definitions for the added VFCs in the Definitions directory, * the interface template contains the relationship declaration * @param downloadedCsarName download Tosca CSAR filename * @throws UnzipException */ private void checkCsarPackage(final String downloadedCsarName) throws UnzipException { final Map filesFromZip = extractFilesFromCsar(downloadedCsarName); final String virtualFunctionName = vfResourceCreateData.getName().replace("-", "").toLowerCase(); final List expectedDefinitionFolderFileList = getExpectedDefinitionFolderFileList(virtualFunctionName); final Map expectedFilesFromZipMap = filesFromZip.entrySet().parallelStream() .filter(key -> expectedDefinitionFolderFileList.stream() .anyMatch(filename -> filename.equalsIgnoreCase(key.getKey()))).collect(Collectors.toMap(Entry::getKey, Entry::getValue)); final String vfResourceTemplateFile = "Definitions/resource-" + virtualFunctionName + "-template.yml"; final String generatedTemplateFile = expectedFilesFromZipMap.keySet().stream() .filter(filename -> filename.equalsIgnoreCase(vfResourceTemplateFile)).findFirst() .orElseThrow(() -> new UiTestFlowRuntimeException(String.format("Resource template file not found %s", vfResourceTemplateFile))); final byte[] toscaTemplateGenerated = filesFromZip.get(generatedTemplateFile); assertThat(toscaTemplateGenerated, is(notNullValue())); verifyGeneratedTemplate(toscaTemplateGenerated, generatedTemplateFile); verifyNodesRelationship(expectedFilesFromZipMap, virtualFunctionName, filesFromZip); } private Map extractFilesFromCsar(final String downloadedCsarName) throws UnzipException { final String downloadFolderPath = getConfig().getDownloadAutomationFolder(); final Map filesFromCsar = FileHandling.getFilesFromZip(downloadFolderPath, downloadedCsarName); return filesFromCsar; } private void verifyGeneratedTemplate(final byte[] generatedTemplateData, final String generatedTemplateFile) { final Map templateYamlMap = loadYamlObject(generatedTemplateData); final boolean hasToscaDefinitionVersionEntry = templateYamlMap.containsKey("tosca_definitions_version"); assertThat(String.format("'%s' should contain tosca_definitions_version entry", generatedTemplateFile), hasToscaDefinitionVersionEntry, is(true)); final String toscaVersion = (String) templateYamlMap.get("tosca_definitions_version"); assertThat(String.format("'%s' tosca_definitions_version entry should have tosca_simple_yaml_1_3 value", generatedTemplateFile), toscaVersion.equalsIgnoreCase("tosca_simple_yaml_1_3")); final Map topologyTemplateTosca = getMapEntry(templateYamlMap, "topology_template"); assertThat(String.format("'%s' should contain a topology_template entry", generatedTemplateFile), topologyTemplateTosca, is(notNullValue())); final Map nodeTemplatesTosca = getMapEntry(topologyTemplateTosca, "node_templates"); assertThat(String.format("'%s' should contain a node_templates entry", generatedTemplateFile), nodeTemplatesTosca, is(notNullValue())); final List nodeTemplateFound = nodeTemplatesTosca.keySet().parallelStream().filter(s -> vfcs.stream() .anyMatch(vfc -> s.startsWith(vfc.getName()))).collect(Collectors.toList()); assertThat(String.format("'%s' should contain the node type definitions for the added VFCs '%s'", nodeTemplatesTosca, vfcs), nodeTemplateFound, hasSize(vfcs.size())); verifyRelationshipTemplate(topologyTemplateTosca, generatedTemplateFile); } private void verifyRelationshipTemplate(final Map topologyTemplateToscaMap, final String generatedTemplateFile) { final Map relationshipTemplateMap = getMapEntry(topologyTemplateToscaMap, "relationship_templates"); assertThat(String.format("'%s' should contain a topology_template entry", generatedTemplateFile), relationshipTemplateMap, is(notNullValue())); final String result = Arrays.asList(relationshipTemplateMap.values()).toString(); assertThat(String.format("'%s' should contain a DependsOn relationship", relationshipTemplateMap), result.contains("tosca.relationships.DependsOn"), is(true)); assertThat(String.format("'%s' should contain interfaces entry", relationshipTemplateMap), result.contains("interfaces"), is(true)); assertThat(String.format("'%s' should contain a Interface Name entry '%s'", relationshipTemplateMap, interfaceName), result.contains(interfaceName), is(true)); assertThat(String.format("'%s' should contain a Interface Operation Name '%s'", relationshipTemplateMap, interfaceOperationName), result.contains(interfaceOperationName), is(true)); assertThat(String.format("'%s' should contain Implementation Name '%s'", relationshipTemplateMap, implementationName), result.contains(implementationName), is(true)); assertThat(String.format("'%s' should contain inputs entry", relationshipTemplateMap), result.contains("inputs"), is(true)); assertThat(String.format("'%s' should contain Input Name '%s'", relationshipTemplateMap, inputName), result.contains(inputName), is(true)); assertThat(String.format("'%s' should contain Input Value '%s'", relationshipTemplateMap, inputValue), result.contains(inputValue), is(true)); } private void verifyNodesRelationship(final Map expectedFilesFromZipMap, final String virtualFunctionName, final Map filesFromZip) { final String vfResourceTemplateFile = "Definitions/resource-" + virtualFunctionName + "-template-interface.yml"; final String interfaceTemplateFile = expectedFilesFromZipMap.keySet().stream() .filter(filename -> filename.equalsIgnoreCase(vfResourceTemplateFile)).findFirst() .orElseThrow(() -> new UiTestFlowRuntimeException(String.format("Resource template file not found %s", vfResourceTemplateFile))); final byte[] toscaInterfaceTemplateGenerated = filesFromZip.get(interfaceTemplateFile); assertThat(toscaInterfaceTemplateGenerated, is(notNullValue())); final Map interfaceTemplateYamlMap = loadYamlObject(toscaInterfaceTemplateGenerated); final Map nodeTypesYamlMap = getMapEntry(interfaceTemplateYamlMap, "node_types"); assertThat(String.format("'%s' should contain a node_types entry", interfaceTemplateYamlMap), nodeTypesYamlMap, is(notNullValue())); final String result = Arrays.asList(nodeTypesYamlMap.values()).toString(); assertThat(String.format("'%s' should contain a capabilities entry", nodeTypesYamlMap), result.contains("capabilities"), is(true)); assertThat(String.format("'%s' should contain a requirements entry", nodeTypesYamlMap), result.contains("requirements"), is(true)); assertThat(String.format("'%s' should contain a relationship entry", nodeTypesYamlMap), result.contains("relationship"), is(true)); assertThat(String.format("'%s' should contain a DependsOn relationship value", nodeTypesYamlMap), result.contains("tosca.relationships.DependsOn"), is(true)); } private List getExpectedDefinitionFolderFileList(final String vfResourceName) { final List expectedDefinitionFolderFileList = new ArrayList<>(); vfcs.forEach(vfc -> expectedDefinitionFolderFileList.add("Definitions/resource-" + vfc.getName() + "-template.yml")); expectedDefinitionFolderFileList.add("Definitions/resource-" + vfResourceName + "-template.yml"); expectedDefinitionFolderFileList.add("Definitions/resource-" + vfResourceName + "-template-interface.yml"); return expectedDefinitionFolderFileList; } private void verifyToscaTemplateHasDeclareInput(Map yaml) { assertNotNull(yaml, "No contents in TOSCA Template"); final Map toscaYaml = (Map) yaml; final Map topologyTemplateTosca = getMapEntry(toscaYaml, "topology_template"); assertThat(String.format("'%s' should contain a topology_template entry", toscaYaml), topologyTemplateTosca, notNullValue()); final Map inputsTosca = getMapEntry(topologyTemplateTosca, "inputs"); assertThat(String.format("'%s' should contain a inputs entry", toscaYaml), inputsTosca, notNullValue()); assertEquals(2, inputsTosca.keySet().stream() .filter(s -> (s.contains("resourceSubtype") || s.contains("property1"))).count()); final Map substitutionMapping = getMapEntry(topologyTemplateTosca, "substitution_mappings"); assertThat(String.format("'%s' should contain a substitution_mappings entry", toscaYaml), substitutionMapping, notNullValue()); final Map substitutionMappingProperties = getMapEntry(substitutionMapping, "properties"); assertThat(String.format("'%s' should contain a properties entry", toscaYaml), substitutionMappingProperties, notNullValue()); assertEquals(2, substitutionMappingProperties.keySet().stream() .filter(s -> (s.contains("resourceSubtype") || s.contains("property1"))).count()); } private void verifyToscaTemplateAddInput(Map yaml) { final Map inputMap = loadInputsToAdd(); assertNotNull(yaml, "No contents in TOSCA Template"); final Map toscaYaml = (Map) yaml; final Map topologyTemplateTosca = getMapEntry(toscaYaml, "topology_template"); assertThat(String.format("'%s' should contain a topology_template entry", toscaYaml), topologyTemplateTosca, notNullValue()); final Map inputsTosca = getMapEntry(topologyTemplateTosca, "inputs"); assertThat(String.format("'%s' should contain a inputs entry", toscaYaml), inputsTosca, notNullValue()); assertEquals(3, inputsTosca.keySet().stream() .filter(s -> inputMap.containsKey(s)).count()); } private Map getMapEntry(final Map yamlObj, final String entryName) { try { return (Map) yamlObj.get(entryName); } catch (final Exception e) { final String errorMsg = String.format("Could not get the '%s' entry.", entryName); LOGGER.error(errorMsg, e); fail(errorMsg + "Error message: " + e.getMessage()); } return null; } private Map loadYamlObject(final byte[] definitionYamlFile) { return new Yaml().load(new String(definitionYamlFile)); } private Map loadPropertiesToAdd() { final Map propertyMap = new HashMap<>(); propertyMap.put("property1", "string"); propertyMap.put("property2", "integer"); propertyMap.put("property3", "boolean"); propertyMap.put("property4", "list"); propertyMap.put("property5", "map"); propertyMap.put("property6", "scalar-unit.size"); return propertyMap; } private Map loadPropertiesToEdit() { final Map propertyMap = new HashMap<>(); propertyMap.put("property1", "Integration Test"); propertyMap.put("property2", 100); propertyMap.put("property3", Boolean.TRUE); propertyMap.put("property4", Arrays.asList("PropListV1", "PropListV2", "PropListV3")); final Map stringMap = new HashMap<>(); stringMap.put("PropMapKey1", "PropMapValue1"); stringMap.put("PropMapKey2", "PropMapValue2"); stringMap.put("PropMapKey3", "PropMapValue3"); propertyMap.put("property5", stringMap); propertyMap.put("property6", "500 GB"); return propertyMap; } private Map loadInputsToAdd() { final Map inputMap = new HashMap<>(); inputMap.put("input1", "string"); inputMap.put("input2", "integer"); inputMap.put("input3", "boolean"); return inputMap; } private void loadSubstitutionFilterProperties() { final ResourcePropertiesAssignmentPage propertiesPage = componentPage.goToPropertiesAssignment(); propertiesPage.isLoaded(); ExtentTestActions.takeScreenshot(Status.INFO, "propertiesAssigment", String.format("The %s Properties Assignment Page is loaded", vfResourceCreateData.getName())); Map propertyNamesAndTypes = propertiesPage.getPropertyNamesAndTypes(); assertThat(String.format("The Component '%s' should have properties", vfResourceCreateData.getName()), propertyNamesAndTypes, not(anEmptyMap())); propertyNamesAndTypes.forEach((name, type) -> substitutionFilterProperties.add(new ServiceDependencyProperty(name, type, getPropertyValueByType(type), LogicalOperator.EQUALS))); } private String getPropertyValueByType(final String type) { switch (type) { case "string": return "IntegrationTest"; case "integer": return "202"; case "size": return "500"; case "boolean": return "TRUE"; case "list": return "[\"value1\", \"value2\"]"; case "map": return "{\"MyKey\": \"MyValue\"}"; default: throw new UnsupportedOperationException("Not yet implemented for " + type); } } /** * Downloads Tosca Template file * @return the tosca template yaml file * @throws Exception */ private Map downloadToscaTemplate() throws Exception { final DownloadToscaTemplateFlow downloadToscaTemplateFlow = new DownloadToscaTemplateFlow(webDriver); final ToscaArtifactsPage toscaArtifactsPage = (ToscaArtifactsPage) downloadToscaTemplateFlow.run(componentPage).get(); return FileHandling.parseYamlFile(getConfig().getDownloadAutomationFolder() .concat(java.io.File.separator).concat(toscaArtifactsPage.getDownloadedArtifactList().get(0))); } private void verifyToscaTemplateHasSubstitutionFilter(final Map yaml) { assertNotNull(yaml, "No contents in TOSCA Template"); final List substitutionFilters = (List) getSubstitutionFilterFromYaml(yaml).get("properties"); substitutionFilterProperties.forEach(substitutionFilterProperty -> { final Map substitutionFilterMap = (Map) substitutionFilters.stream() .filter(subFilter -> ((Map) subFilter).containsKey(substitutionFilterProperty.getName())).findAny().get(); assertThat("Added substitution filter not found in TOSCA Template", substitutionFilterMap.containsKey(substitutionFilterProperty.getName())); final Map substitutionFilterValue = (Map) ((List) substitutionFilterMap.get(substitutionFilterProperty.getName())).get(0); assertThat("Substitution Filter Value should not be empty", substitutionFilterMap, not(anEmptyMap())); final String expectedSubstitutionPropertyValue = substitutionFilterProperty.getValue().replaceAll("[\"{}]", ""); final String actualSubstitutionPropertyValue = substitutionFilterValue.values().stream().findFirst().get() instanceof Map ? substitutionFilterValue.values().stream().findFirst().get().toString().replace("=", ": ") .replaceAll("\\{(.*?)\\}", "$1").trim() : substitutionFilterValue.values().stream().findFirst().get().toString(); assertThat("Invalid value for added substitution filters found in TOSCA Template", expectedSubstitutionPropertyValue.equalsIgnoreCase(actualSubstitutionPropertyValue)); assertThat("Invalid logical operator for added substitution filters found in TOSCA Template", substitutionFilterValue.containsKey(substitutionFilterProperty.getLogicalOperator().getName())); }); } private Map getSubstitutionFilterFromYaml(final Map yaml) { final Map topology = (Map) yaml.get("topology_template"); final Map substitutionMappings = (Map) topology.get("substitution_mappings"); return (Map) substitutionMappings.get("substitution_filter"); } private void verifyAvailableDirectiveTypes(final List availableDirectiveTypes) { assertNotNull(availableDirectiveTypes, "Expected list of available Directive Types, but recieved null"); Arrays.asList(DirectiveType.values()).forEach(directiveType -> { assertTrue(availableDirectiveTypes.contains(directiveType.getName()) , String.format("Expected directive %s to be availabe in UI options %s" , directiveType.getName(), availableDirectiveTypes.toString())); }); ExtentTestActions.log(Status.PASS, "All expected directive types are available for selection"); } private void verifyAvailablePropertyNames(List propertyNames, List propertyNameOptions) { assertEquals(propertyNameOptions.size(), propertyNames.size(), "Mismatch in the number of properties available for selection"); propertyNames.forEach(name -> { assertNotEquals(false, propertyNameOptions.remove(name) , String.format("Expected property %s not found in UI Select element", name)); }); ExtentTestActions.log(Status.PASS, "All expected properties are available for selection"); } private void verifyToscaTemplateHasDirectiveNodeFilter(final Map yaml, ServiceDependencyProperty nodeFilterProperty, String nodeTemplateName) { assertNotNull(yaml, "Tosca Template Yaml is not expected to be empty"); final List nodeFilters = (List) getDirectiveNodeFilterFromYaml(yaml, nodeTemplateName).get("properties"); final Map nodeFilter = (Map) nodeFilters.stream() .filter(yamlNodeFilter -> ((Map) yamlNodeFilter).containsKey(nodeFilterProperty.getName())).findAny().get(); assertNotNull(nodeFilter, "Added directive node filter not found in TOSCA Template"); final Map nodeFilterValue = (Map) ((List) nodeFilter.get(nodeFilterProperty.getName())).get(0); assertTrue(nodeFilterValue.containsValue(nodeFilterProperty.getValue()) , "Invalid value for added directive node filter found in TOSCA Template"); assertTrue(nodeFilterValue.containsKey(nodeFilterProperty.getLogicalOperator().getName()) , "Invalid logical operator for added directive node filter found in TOSCA Template"); } private Map getDirectiveNodeFilterFromYaml(final Map yaml, String nodeTemplateName) { final Map topology = (Map) yaml.get("topology_template"); final Map nodeTemplates = (Map) topology.get("node_templates"); final Map resourceNode = (Map) nodeTemplates.get(nodeTemplateName); return (Map) resourceNode.get("node_filter"); } }