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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * Copyright (C) 2021 Nokia. All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.sdc.frontend.ci.tests.execute.sanity;
  23
  24 import static org.testng.AssertJUnit.assertEquals;
  25 import static org.testng.AssertJUnit.assertFalse;
  26 import static org.testng.AssertJUnit.assertNotNull;
  27 import static org.testng.AssertJUnit.assertTrue;
  28 import static org.testng.AssertJUnit.fail;
  29
  30 import com.aventstack.extentreports.ExtentTest;
  31 import com.aventstack.extentreports.Status;
  32 import java.io.File;
  33 import java.util.Arrays;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.stream.Collectors;
  38 import org.onap.sdc.backend.ci.tests.data.providers.OnboardingDataProviders;
  39 import org.onap.sdc.backend.ci.tests.datatypes.ResourceReqDetails;
  40 import org.onap.sdc.backend.ci.tests.datatypes.ServiceReqDetails;
  41 import org.onap.sdc.backend.ci.tests.datatypes.VendorLicenseModel;
  42 import org.onap.sdc.backend.ci.tests.datatypes.VendorSoftwareProductObject;
  43 import org.onap.sdc.backend.ci.tests.datatypes.enums.UserRoleEnum;
  44 import org.onap.sdc.backend.ci.tests.datatypes.enums.XnfTypeEnum;
  45 import org.onap.sdc.backend.ci.tests.utils.Utils;
  46 import org.onap.sdc.backend.ci.tests.utils.general.AtomicOperationUtils;
  47 import org.onap.sdc.backend.ci.tests.utils.general.ElementFactory;
  48 import org.onap.sdc.backend.ci.tests.utils.general.OnboardingUtils;
  49 import org.onap.sdc.backend.ci.tests.utils.general.VendorLicenseModelRestUtils;
  50 import org.onap.sdc.backend.ci.tests.utils.general.VendorSoftwareProductRestUtils;
  51 import org.onap.sdc.frontend.ci.tests.dataProvider.OnbordingDataProviders;
  52 import org.onap.sdc.frontend.ci.tests.datatypes.CanvasElement;
  53 import org.onap.sdc.frontend.ci.tests.datatypes.CanvasManager;
  54 import org.onap.sdc.frontend.ci.tests.datatypes.DataTestIdEnum;
  55 import org.onap.sdc.frontend.ci.tests.execute.setup.DriverFactory;
  56 import org.onap.sdc.frontend.ci.tests.execute.setup.ExtentTestActions;
  57 import org.onap.sdc.frontend.ci.tests.execute.setup.SetupCDTest;
  58 import org.onap.sdc.frontend.ci.tests.flow.CheckSoftwareVersionPropertyFlow;
  59 import org.onap.sdc.frontend.ci.tests.flow.CreateResourceFlow;
  60 import org.onap.sdc.frontend.ci.tests.flow.CreateVspFlow;
  61 import org.onap.sdc.frontend.ci.tests.flow.ImportVspFlow;
  62 import org.onap.sdc.frontend.ci.tests.flow.exception.UiTestFlowRuntimeException;
  63 import org.onap.sdc.frontend.ci.tests.pages.CompositionPage;
  64 import org.onap.sdc.frontend.ci.tests.pages.DeploymentArtifactPage;
  65 import org.onap.sdc.frontend.ci.tests.pages.GeneralPageElements;
  66 import org.onap.sdc.frontend.ci.tests.pages.GovernorOperationPage;
  67 import org.onap.sdc.frontend.ci.tests.pages.HomePage;
  68 import org.onap.sdc.frontend.ci.tests.pages.OpsOperationPage;
  69 import org.onap.sdc.frontend.ci.tests.pages.ResourceCreatePage;
  70 import org.onap.sdc.frontend.ci.tests.pages.ResourceGeneralPage;
  71 import org.onap.sdc.frontend.ci.tests.pages.ServiceGeneralPage;
  72 import org.onap.sdc.frontend.ci.tests.pages.TesterOperationPage;
  73 import org.onap.sdc.frontend.ci.tests.pages.TopNavComponent;
  74 import org.onap.sdc.frontend.ci.tests.pages.VspValidationPage;
  75 import org.onap.sdc.frontend.ci.tests.pages.VspValidationResultsPage;
  76 import org.onap.sdc.frontend.ci.tests.utilities.FileHandling;
  77 import org.onap.sdc.frontend.ci.tests.utilities.GeneralUIUtils;
  78 import org.onap.sdc.frontend.ci.tests.utilities.OnboardingUiUtils;
  79 import org.onap.sdc.frontend.ci.tests.utilities.ServiceUIUtils;
  80 import org.onap.sdc.frontend.ci.tests.verificator.ServiceVerificator;
  81 import org.openecomp.sdc.be.model.ComponentInstance;
  82 import org.openecomp.sdc.be.model.Resource;
  83 import org.openecomp.sdc.be.model.Service;
  84 import org.openqa.selenium.WebDriver;
  85 import org.openqa.selenium.WebElement;
  86 import org.slf4j.Logger;
  87 import org.slf4j.LoggerFactory;
  88 import org.testng.Assert;
  89 import org.testng.AssertJUnit;
  90 import org.testng.annotations.BeforeMethod;
  91 import org.testng.annotations.Optional;
  92 import org.testng.annotations.Parameters;
  93 import org.testng.annotations.Test;
  94
  95 public class OnboardingFlowsUi extends SetupCDTest {
  96
  97     private static final Logger LOGGER = LoggerFactory.getLogger(OnboardingFlowsUi.class);
  98     private static final String NO_TESTS_ARE_AVAILABLE = "No Tests are Available";
  99     private static final String NEXT_BUTTON_IS_ENABLED_IT_SHOULD_HAVE_BEEN_ENABLED =
 100             "Next Button is enabled, it should have been enabled";
 101     private static final String NEXT_BUTTON_IS_DISABLED_IT_SHOULD_HAVE_BEEN_ENABLED =
 102             "Next Button is disabled, it should have been enabled";
 103     private static final String RESULTS_ARE_NOT_AVAILABLE = "Results are not available";
 104     private static final String THE_TESTS_ARE_ALREADY_SELECTED_THE_LIST_SHOULD_INITIALLY_BE_EMPTY =
 105             "The tests are already selected, the list should initially be empty";
 106     private static final String THE_SELECTED_TESTS_ARE_NOT_POPULATED_IN_THE_LIST =
 107             "The selected tests are not populated in the list";
 108     private static final String THE_SELECTED_TESTS_ARE_NOT_DELETED_FROM_THE_LIST =
 109             "The selected tests are not deleted from the list";
 110     private static final String NEXT_BUTTON_IS_ENABLED_IT_SHOULD_HAVE_BEEN_DISABLED =
 111             "Next Button is enabled, it should have been disabled";
 112
 113     protected static String filePath = FileHandling.getVnfRepositoryPath();
 114     private Boolean makeDistributionValue;
 115
 116     @Parameters({"makeDistribution"})
 117     @BeforeMethod
 118     public void beforeTestReadParams(@Optional("true") String makeDistributionReadValue) {
 119         LOGGER.debug("makeDistribution parameter is '{}'", makeDistributionReadValue);
 120         makeDistributionValue = Boolean.valueOf(makeDistributionReadValue);
 121     }
 122
 123     @Test
 124     public void onboardVNFTestSanityOneFile() throws Exception {
 125         String vnfFile = "1-VF-vUSP-vCCF-DB_v11.1.zip";
 126         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 127         ServiceReqDetails serviceReqDetails = ElementFactory.getDefaultService();
 128         runOnboardToDistributionFlow(resourceReqDetails, serviceReqDetails, filePath, vnfFile);
 129     }
 130
 131     @Test
 132     public void performanceTest() throws Exception {
 133         LOGGER.debug("Start test");
 134         Long actualTestRunTime = Utils.getActionDuration(() -> {
 135             try {
 136                 onboardVNFTestSanityOneFile();
 137             } catch (final Exception e) {
 138                 LOGGER.debug("An error has occurred during the performance test", e);
 139             }
 140         });
 141         long regularTestRunTime = 400L;
 142         double factor = 1.5;
 143         assertTrue("Expected test run time should be less from " + regularTestRunTime * factor + ", actual time is " + actualTestRunTime, regularTestRunTime * factor > actualTestRunTime);
 144     }
 145
 146     @Test
 147     public void onboardVNFTestSanity() throws Exception {
 148         List<String> fileNamesFromFolder = OnboardingUtils.getXnfNamesFileList(XnfTypeEnum.VNF);
 149         String vnfFile = fileNamesFromFolder.get(0);
 150         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 151         ServiceReqDetails serviceReqDetails = ElementFactory.getDefaultService();
 152         runOnboardToDistributionFlow(resourceReqDetails, serviceReqDetails, filePath, vnfFile);
 153     }
 154
 155     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "Single_VNF")
 156     public void onapOnboardVNFflow(String filePath, String vnfFile) throws Exception {
 157         setLog(vnfFile);
 158         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 159         ServiceReqDetails serviceReqDetails = ElementFactory.getDefaultService();
 160         runOnboardToDistributionFlow(resourceReqDetails, serviceReqDetails, filePath, vnfFile);
 161     }
 162
 163     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "Single_VNF")
 164     public void onapOnboardVSPValidationsSanityFlow(String filePath, String vnfFile) throws Exception {
 165         setLog(vnfFile);
 166         String vspName = createNewVSP(filePath, vnfFile);
 167         if (OnboardingUiUtils.getVspValidationCongiguration()) {
 168             goToVspScreen(true, vspName);
 169
 170             //check links are available
 171             checkVspValidationLinksVisibility();
 172
 173             VspValidationPage.navigateToVspValidationPageUsingNavbar();
 174             assertTrue(NEXT_BUTTON_IS_ENABLED_IT_SHOULD_HAVE_BEEN_DISABLED,
 175                     VspValidationPage.checkNextButtonDisabled());
 176             VspValidationResultsPage.navigateToVspValidationResultsPageUsingNavbar();
 177             GeneralUIUtils.ultimateWait();
 178             assertNotNull(GeneralUIUtils.findByText("No Test Performed"));
 179         } else {
 180             goToVspScreen(true, vspName);
 181
 182             //check links are not available
 183             checkVspValidationLinksInvisibility();
 184         }
 185     }
 186
 187     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "softwareInformationPnf")
 188     public void onboardPNFSoftwareInformationFlow(final String rootFolder, final String pnfFile,
 189                                                   final List<String> softwareVersionList) {
 190         setLog(pnfFile);
 191         final String resourceName = ElementFactory.addRandomSuffixToName(ElementFactory.getResourcePrefix());
 192         runOnboardPnfSoftwareVersion(resourceName, rootFolder, pnfFile, softwareVersionList);
 193     }
 194
 195     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "Single_VNF")
 196     public void onapOnboardVSPValidationsConfigurationChangeCheck(String filePath, String vnfFile) throws Exception {
 197         setLog(vnfFile);
 198         String vspName = createNewVSP(filePath, vnfFile);
 199         if (OnboardingUiUtils.getVspValidationCongiguration()) {
 200             goToVspScreen(true, vspName);
 201             //check links are available
 202             checkVspValidationLinksVisibility();
 203
 204             //change config
 205             changeVspValidationConfig(false, vspName, OnboardingUiUtils.getVspValidationCongiguration());
 206
 207             //check links are not available
 208             checkVspValidationLinksInvisibility();
 209         } else {
 210             goToVspScreen(true, vspName);
 211             //check links are not available
 212             checkVspValidationLinksInvisibility();
 213
 214             changeVspValidationConfig(false, vspName, OnboardingUiUtils.getVspValidationCongiguration());
 215
 216             //check links are available
 217             checkVspValidationLinksVisibility();
 218         }
 219     }
 220
 221     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "Single_VNF")
 222     public void onapOnboardVSPCertificationQueryFlow(String filePath, String vnfFile) throws Exception {
 223         setLog(vnfFile);
 224         String vspName = createNewVSP(filePath, vnfFile);
 225         if (!OnboardingUiUtils.getVspValidationCongiguration()) {
 226             //change config to true to test the feature
 227             changeVspValidationConfig(true, vspName, OnboardingUiUtils.getVspValidationCongiguration());
 228         } else {
 229             goToVspScreen(true, vspName);
 230         }
 231         VspValidationPage.navigateToVspValidationPageUsingNavbar();
 232         assertTrue(NEXT_BUTTON_IS_ENABLED_IT_SHOULD_HAVE_BEEN_DISABLED, VspValidationPage.checkNextButtonDisabled());
 233
 234         if (VspValidationPage.checkCertificationQueryExists()) {
 235             VspValidationPage.clickCertificationQueryAll();
 236             GeneralUIUtils.ultimateWait();
 237             assertTrue(NEXT_BUTTON_IS_DISABLED_IT_SHOULD_HAVE_BEEN_ENABLED,
 238                     !VspValidationPage.checkNextButtonDisabled());
 239             VspValidationPage.clickOnNextButton();
 240             GeneralUIUtils.ultimateWait();
 241             VspValidationPage.clickOnSubmitButton();
 242             GeneralUIUtils.waitForLoader();
 243             assertTrue(RESULTS_ARE_NOT_AVAILABLE, VspValidationResultsPage.checkResultsExist());
 244         } else {
 245             assertNotNull(GeneralUIUtils.findByText("No Certifications Query are Available"));
 246         }
 247
 248     }
 249
 250     @Test(dataProviderClass = OnbordingDataProviders.class, dataProvider = "Single_Vsp_Test_Csar")
 251     public void onapOnboardVSPComplianceCheckFlow(String filePath, String vnfFile) throws Exception {
 252         setLog(vnfFile);
 253         String vspName = createNewVSP(filePath, vnfFile);
 254         if (!OnboardingUiUtils.getVspValidationCongiguration()) {
 255             //change config to true to test the feature
 256             changeVspValidationConfig(true, vspName, OnboardingUiUtils.getVspValidationCongiguration());
 257         } else {
 258             goToVspScreen(true, vspName);
 259         }
 260
 261         VspValidationPage.navigateToVspValidationPageUsingNavbar();
 262         assertTrue(NEXT_BUTTON_IS_ENABLED_IT_SHOULD_HAVE_BEEN_ENABLED, VspValidationPage.checkNextButtonDisabled());
 263         if (VspValidationPage.checkComplianceCheckExists()) {
 264             VspValidationPage.clickComplianceChecksAll();
 265             GeneralUIUtils.ultimateWait();
 266             assertFalse(NEXT_BUTTON_IS_DISABLED_IT_SHOULD_HAVE_BEEN_ENABLED,
 267                     VspValidationPage.checkNextButtonDisabled());
 268             VspValidationPage.clickOnNextButton();
 269             GeneralUIUtils.ultimateWait();
 270             VspValidationPage.loadVSPFile(filePath, vnfFile);
 271             VspValidationPage.clickOnSubmitButton();
 272             GeneralUIUtils.ultimateWait();
 273             assertTrue(RESULTS_ARE_NOT_AVAILABLE, VspValidationResultsPage.checkResultsExist());
 274         } else {
 275             assertNotNull(GeneralUIUtils.findByText(NO_TESTS_ARE_AVAILABLE));
 276         }
 277
 278     }
 279
 280     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "Single_VNF")
 281     public void onapOnboardVSPComplianceCheckOperations(String filePath, String vnfFile) throws Exception {
 282         setLog(vnfFile);
 283         String vspName = createNewVSP(filePath, vnfFile);
 284         if (!OnboardingUiUtils.getVspValidationCongiguration()) {
 285             //change config to true to test the feature
 286             changeVspValidationConfig(true, vspName, OnboardingUiUtils.getVspValidationCongiguration());
 287         } else {
 288             goToVspScreen(true, vspName);
 289         }
 290
 291         VspValidationPage.navigateToVspValidationPageUsingNavbar();
 292         assertTrue(NEXT_BUTTON_IS_ENABLED_IT_SHOULD_HAVE_BEEN_ENABLED, VspValidationPage.checkNextButtonDisabled());
 293         if (VspValidationPage.checkComplianceCheckExists()) {
 294             assertFalse(THE_TESTS_ARE_ALREADY_SELECTED_THE_LIST_SHOULD_INITIALLY_BE_EMPTY,
 295                     VspValidationPage.checkSelectedComplianceCheckExists());
 296             VspValidationPage.clickComplianceChecksAll();
 297             GeneralUIUtils.ultimateWait();
 298             assertTrue(THE_SELECTED_TESTS_ARE_NOT_POPULATED_IN_THE_LIST,
 299                     VspValidationPage.checkSelectedComplianceCheckExists());
 300             VspValidationPage.clickComplianceChecksAll();
 301             GeneralUIUtils.ultimateWait();
 302             assertFalse(THE_SELECTED_TESTS_ARE_NOT_DELETED_FROM_THE_LIST,
 303                     VspValidationPage.checkSelectedComplianceCheckExists());
 304         } else {
 305             assertNotNull(GeneralUIUtils.findByText(NO_TESTS_ARE_AVAILABLE));
 306         }
 307
 308     }
 309
 310     @Test(dataProviderClass = OnboardingDataProviders.class, dataProvider = "Single_VNF")
 311     public void onapOnboardVSPCertificationQueryOperations(String filePath, String vnfFile) throws Exception {
 312         setLog(vnfFile);
 313         String vspName = createNewVSP(filePath, vnfFile);
 314         if (!OnboardingUiUtils.getVspValidationCongiguration()) {
 315             //change config to true to test the feature
 316             changeVspValidationConfig(true, vspName, OnboardingUiUtils.getVspValidationCongiguration());
 317         } else {
 318             goToVspScreen(true, vspName);
 319         }
 320
 321         VspValidationPage.navigateToVspValidationPageUsingNavbar();
 322         assertTrue(NEXT_BUTTON_IS_ENABLED_IT_SHOULD_HAVE_BEEN_ENABLED, VspValidationPage.checkNextButtonDisabled());
 323         if (VspValidationPage.checkCertificationQueryExists()) {
 324             assertFalse(THE_TESTS_ARE_ALREADY_SELECTED_THE_LIST_SHOULD_INITIALLY_BE_EMPTY,
 325                 VspValidationPage.checkSelectedCertificationQueryExists());
 326             VspValidationPage.clickCertificationQueryAll();
 327             GeneralUIUtils.ultimateWait();
 328             assertTrue(THE_SELECTED_TESTS_ARE_NOT_POPULATED_IN_THE_LIST, VspValidationPage.checkSelectedCertificationQueryExists());
 329             VspValidationPage.clickCertificationQueryAll();
 330             GeneralUIUtils.ultimateWait();
 331             assertFalse(THE_SELECTED_TESTS_ARE_NOT_DELETED_FROM_THE_LIST,
 332                 VspValidationPage.checkSelectedCertificationQueryExists());
 333         } else {
 334             assertNotNull(GeneralUIUtils.findByText(NO_TESTS_ARE_AVAILABLE));
 335         }
 336
 337     }
 338
 339     private void checkVspValidationLinksVisibility() {
 340         //check links are available
 341         assertTrue("Validation Link is not available", GeneralUIUtils.isElementVisibleByTestId(DataTestIdEnum.VspValidationPage.VSP_VALIDATION_PAGE_NAVBAR.getValue()));
 342         assertTrue("Validation Results Link is not available", GeneralUIUtils.isElementVisibleByTestId(DataTestIdEnum.VspValidationResultsPage.VSP_VALIDATION_RESULTS_PAGE_NAVBAR.getValue()));
 343     }
 344
 345     private void checkVspValidationLinksInvisibility() {
 346         //check links not available
 347         assertTrue("Validation Link is still available", GeneralUIUtils.isElementInvisibleByTestId(DataTestIdEnum.VspValidationPage.VSP_VALIDATION_PAGE_NAVBAR.getValue()));
 348         assertTrue("Validation Results Link is still available", GeneralUIUtils.isElementInvisibleByTestId(DataTestIdEnum.VspValidationResultsPage.VSP_VALIDATION_RESULTS_PAGE_NAVBAR.getValue()));
 349     }
 350
 351     private void changeVspValidationConfig(boolean isCurrentScreenCatalogPage, String vspName, boolean vspConfig) throws Exception {
 352         //change config
 353         OnboardingUiUtils.putVspValidationCongiguration(!vspConfig);
 354         assertTrue(String.format("Failed to set Congiguration to %s", !vspConfig), OnboardingUiUtils.getVspValidationCongiguration() != vspConfig);
 355
 356         if (!isCurrentScreenCatalogPage) {
 357             GeneralUIUtils.refreshWebpage();
 358             GeneralUIUtils.ultimateWait();
 359         }
 360
 361         goToVspScreen(isCurrentScreenCatalogPage, vspName);
 362
 363         //revert the config
 364         OnboardingUiUtils.putVspValidationCongiguration(vspConfig);
 365         assertEquals(String.format("Failed to revert Configuration to %s", vspConfig), vspConfig,
 366             OnboardingUiUtils.getVspValidationCongiguration());
 367     }
 368
 369     private void goToVspScreen(boolean isCurrentScreenCatalogPage, String vspName) {
 370         if (isCurrentScreenCatalogPage) {
 371             GeneralUIUtils.clickOnElementByTestId(DataTestIdEnum.MainMenuButtons.ONBOARD_BUTTON.getValue());
 372         }
 373         GeneralUIUtils.clickOnElementByText(vspName);
 374         GeneralUIUtils.ultimateWait();
 375     }
 376
 377     private String createNewVSP(String filePath, String vnfFile) throws Exception {
 378         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 379         return OnboardingUiUtils.createVSP(resourceReqDetails, vnfFile, filePath, getUser()).getName();
 380     }
 381
 382     public void runOnboardPnfSoftwareVersion(final String resourceName, final String rootFolder,
 383                                              final String pnfFile, final List<String> softwareVersionList) {
 384         final ExtentTest extendTest = getExtendTest();
 385
 386         final String swVersionsToString = String.join(", ", softwareVersionList);
 387
 388         extendTest.log(Status.INFO,
 389             String.format("Creating VSP '%s' by onboarding package '%s' with software version '%s'",
 390                 resourceName, pnfFile, swVersionsToString)
 391         );
 392         final WebDriver webDriver = DriverFactory.getDriver();
 393         final CreateVspFlow createVspFlow = new CreateVspFlow(webDriver, resourceName, pnfFile, rootFolder);
 394         createVspFlow.run(new TopNavComponent(webDriver));
 395
 396         final ImportVspFlow importVspFlow = new ImportVspFlow(webDriver, resourceName);
 397         final ResourceCreatePage resourceCreatePage = importVspFlow.run()
 398             .orElseThrow(() -> new UiTestFlowRuntimeException("Missing expected return ResourceCreatePage"));
 399         final CreateResourceFlow createResourceFlow = new CreateResourceFlow(webDriver, resourceName);
 400         createResourceFlow.run(resourceCreatePage);
 401
 402         final CheckSoftwareVersionPropertyFlow checkSoftwareVersionPropertyFlow =
 403             new CheckSoftwareVersionPropertyFlow(webDriver, softwareVersionList);
 404         checkSoftwareVersionPropertyFlow.run();
 405
 406         extendTest.log(Status.INFO,
 407             String.format("Successfully onboarded the package '%s' with software version '%s'",
 408                 pnfFile, swVersionsToString)
 409         );
 410     }
 411
 412     private void runOnboardToDistributionFlow(ResourceReqDetails resourceReqDetails, ServiceReqDetails serviceMetadata, String filePath, String vnfFile) throws Exception {
 413         getExtendTest().log(Status.INFO, "Going to create resource with category: " + resourceReqDetails.getCategories().get(0).getName()
 414                 + " subCategory: " + resourceReqDetails.getCategories().get(0).getSubcategories().get(0).getName()
 415                 + " and service category: " + serviceMetadata.getCategory());
 416         final String vspName = onboardAndCertify(resourceReqDetails, filePath, vnfFile);
 417
 418         ServiceUIUtils.createService(serviceMetadata);
 419
 420         ServiceGeneralPage.getLeftMenu().moveToCompositionScreen();
 421         Service containerObject = AtomicOperationUtils.getServiceObjectByNameAndVersion(UserRoleEnum.DESIGNER, serviceMetadata.getName(), "0.1");
 422         Resource instanceObject = AtomicOperationUtils.getResourceObjectByNameAndVersion(UserRoleEnum.DESIGNER, vspName, "1.0");
 423         ComponentInstance componentInstanceDetails = AtomicOperationUtils.addComponentInstanceToComponentContainer(instanceObject, containerObject, UserRoleEnum.DESIGNER, true).left().value();
 424
 425         GeneralUIUtils.clickOnAreaJS(DataTestIdEnum.LifeCyleChangeButtons.CERTIFY.getValue());
 426
 427         GeneralUIUtils.getWebElementByTestID(DataTestIdEnum.DistributionChangeButtons.APPROVE_MESSAGE.getValue())
 428                 .sendKeys("service " + serviceMetadata.getName() + " certified successfully");
 429         GeneralPageElements.clickOKButton();
 430         getExtendTest().log(Status.INFO, String.format("Successfully onboarded the package '%s'", vnfFile));
 431     }
 432
 433     private void runDistributionFlow(final ServiceReqDetails serviceMetadata) throws Exception {
 434         if (makeDistributionValue) {
 435             reloginWithNewRole(UserRoleEnum.OPS);
 436             GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 437             OpsOperationPage.distributeService();
 438             OpsOperationPage.displayMonitor();
 439
 440             final List<WebElement> rowsFromMonitorTable = OpsOperationPage.getRowsFromMonitorTable();
 441             AssertJUnit.assertEquals(1, rowsFromMonitorTable.size());
 442
 443             OpsOperationPage.waitUntilArtifactsDistributed(0);
 444         }
 445     }
 446
 447     private String onboardAndCertify(ResourceReqDetails resourceReqDetails, String filePath, String vnfFile) throws Exception {
 448         VendorSoftwareProductObject onboardAndValidate = OnboardingUiUtils.onboardAndValidate(resourceReqDetails, filePath, vnfFile, getUser());
 449         String vspName = onboardAndValidate.getName();
 450
 451         DeploymentArtifactPage.getLeftPanel().moveToCompositionScreen();
 452         ExtentTestActions.addScreenshot(Status.INFO, "TopologyTemplate_" + vnfFile, "The topology template for " + vnfFile + " is as follows : ");
 453
 454         DeploymentArtifactPage.clickCertifyButton(vspName);
 455         return vspName;
 456     }
 457
 458
 459     @Test(dataProviderClass = OnbordingDataProviders.class, dataProvider = "VNF_List")
 460     public void onboardVNFTest(String filePath, String vnfFile) throws Exception {
 461         setLog(vnfFile);
 462         ResourceReqDetails resourceReqDetails = ElementFactory.getRandomCategoryResource();
 463         ServiceReqDetails serviceReqDetails = ElementFactory.getRandomCategoryService();
 464         runOnboardToDistributionFlow(resourceReqDetails, serviceReqDetails, filePath, vnfFile);
 465     }
 466
 467     @Test(dataProviderClass = OnbordingDataProviders.class, dataProvider = "CNF_List")
 468     public void onboardCNFTest(String filePath, String cnfFile) throws Exception {
 469         setLog(cnfFile);
 470         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 471         ServiceReqDetails serviceReqDetails = ElementFactory.getDefaultService();
 472         runOnboardToDistributionFlow(resourceReqDetails, serviceReqDetails, filePath, cnfFile);
 473     }
 474
 475     @Test(dataProviderClass = OnbordingDataProviders.class, dataProvider = "Invalid_CNF_List")
 476     public void onboardCNFTestShouldFailForInvalidHelmPackage(String filePath, String cnfFile) {
 477         setLog(cnfFile);
 478         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 479         ServiceReqDetails serviceReqDetails = ElementFactory.getDefaultService();
 480         Assert.assertThrows(() -> runOnboardToDistributionFlow(resourceReqDetails, serviceReqDetails, filePath, cnfFile));
 481     }
 482
 483     @Test(dataProviderClass = OnbordingDataProviders.class, dataProvider = "VNF_List")
 484     public void onboardVNFShotFlow(String filePath, String vnfFile) throws Exception {
 485         setLog(vnfFile);
 486         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 487         onboardAndCertify(resourceReqDetails, filePath, vnfFile);
 488     }
 489
 490     @Test(dataProviderClass = OnbordingDataProviders.class, dataProvider = "randomVNF_List")
 491     public void onboardRandomVNFsTest(String filePath, String vnfFile) throws Exception {
 492         setLog(vnfFile);
 493         LOGGER.debug("Vnf File name is: {}", vnfFile);
 494         ResourceReqDetails resourceReqDetails = ElementFactory.getRandomCategoryResource();
 495         ServiceReqDetails serviceReqDetails = ElementFactory.getRandomCategoryService();
 496         runOnboardToDistributionFlow(resourceReqDetails, serviceReqDetails, filePath, vnfFile);
 497     }
 498
 499
 500     @Test
 501     public void onboardUpdateVNFTest() throws Exception {
 502         List<String> fileNamesFromFolder = FileHandling.getZipFileNamesFromFolder(filePath);
 503         String vnfFile = fileNamesFromFolder.get(0);
 504         ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 505         VendorSoftwareProductObject vsp = OnboardingUiUtils.onboardAndValidate(resourceReqDetails, filePath, vnfFile, getUser());
 506         String vspName = vsp.getName();
 507         ResourceGeneralPage.clickCertifyButton(vspName);
 508
 509         // create service
 510         ServiceReqDetails serviceMetadata = ElementFactory.getDefaultService();
 511         ServiceUIUtils.createService(serviceMetadata);
 512
 513         ServiceGeneralPage.getLeftMenu().moveToCompositionScreen();
 514         CompositionPage.searchForElement(vspName);
 515         CanvasManager serviceCanvasManager = CanvasManager.getCanvasManager();
 516         CanvasElement vfElement = serviceCanvasManager.createElementOnCanvas(vspName);
 517         assertNotNull(vfElement);
 518         ServiceVerificator.verifyNumOfComponentInstances(serviceMetadata, "0.1", 1, getUser());
 519
 520         if (!HomePage.navigateToHomePage()) {
 521             fail("Could not go to the home page");
 522         }
 523
 524         ///update flow
 525         String updatedVnfFile = fileNamesFromFolder.get(1);
 526
 527         getExtendTest().log(Status.INFO, String.format("Going to update the VNF with %s......", updatedVnfFile));
 528         // update VendorSoftwareProduct
 529         OnboardingUiUtils.updateVnfAndValidate(filePath, vsp, updatedVnfFile, getUser());
 530         ResourceGeneralPage.clickCertifyButton(vspName);
 531
 532         // replace exiting VFI in service with new updated
 533
 534         GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 535         ServiceGeneralPage.getLeftMenu().moveToCompositionScreen();
 536         serviceCanvasManager = CanvasManager.getCanvasManager();
 537         CompositionPage.changeComponentVersion(serviceCanvasManager, vfElement, "2.0");
 538         ServiceVerificator.verifyNumOfComponentInstances(serviceMetadata, "0.1", 1, getUser());
 539
 540         ServiceGeneralPage.clickSubmitForTestingButton(serviceMetadata.getName());
 541
 542         reloginWithNewRole(UserRoleEnum.TESTER);
 543         GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 544         TesterOperationPage.certifyComponent(serviceMetadata.getName());
 545
 546         reloginWithNewRole(UserRoleEnum.GOVERNOR);
 547         GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 548         GovernorOperationPage.approveService(serviceMetadata.getName());
 549
 550
 551         reloginWithNewRole(UserRoleEnum.OPS);
 552         GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 553         OpsOperationPage.distributeService();
 554         OpsOperationPage.displayMonitor();
 555
 556         List<WebElement> rowsFromMonitorTable = OpsOperationPage.getRowsFromMonitorTable();
 557         AssertJUnit.assertEquals(1, rowsFromMonitorTable.size());
 558
 559         OpsOperationPage.waitUntilArtifactsDistributed(0);
 560         getExtendTest().log(Status.INFO, String.format("Onboarding %s test is passed ! ", vnfFile));
 561     }
 562
 563
 564     @Test
 565     public void threeVMMSCsInServiceTest() throws Exception {
 566         String pathFile = FileHandling.getFilePath("VmmscArtifacts");
 567         final String[] list = new File(pathFile).list();
 568         assertNotNull("Did not find vMMSCs", list);
 569         assertFalse("Did not find vMMSCs", list.length == 0);
 570         List<String> vmmscList = Arrays.stream(list).filter(e -> e.contains("vmmsc") && e.endsWith(".zip"))
 571             .collect(Collectors.toList());
 572         assertFalse("Did not find vMMSCs", vmmscList.isEmpty());
 573
 574         Map<String, String> vspNames = new HashMap<>();
 575         for (String vnfFile : vmmscList) {
 576             String msg = String.format("Going to onboard the VNF %s", vnfFile);
 577             getExtendTest().log(Status.INFO, msg);
 578             LOGGER.info(msg);
 579
 580             VendorLicenseModel vendorLicenseModel = VendorLicenseModelRestUtils.createVendorLicense(getUser());
 581             ResourceReqDetails resourceReqDetails = ElementFactory.getDefaultResource();
 582             VendorSoftwareProductObject createVendorSoftwareProduct = VendorSoftwareProductRestUtils
 583                 .createVendorSoftwareProduct(resourceReqDetails, vnfFile, pathFile, getUser(), vendorLicenseModel);
 584
 585             getExtendTest().log(Status.INFO, String.format("Searching for onboarded %s", vnfFile));
 586             HomePage.showVspRepository();
 587             getExtendTest().log(Status.INFO, String.format("Going to import %s......", vnfFile.substring(0, vnfFile.indexOf("."))));
 588             OnboardingUiUtils.importVSP(createVendorSoftwareProduct);
 589
 590             ResourceGeneralPage.getLeftMenu().moveToDeploymentArtifactScreen();
 591             DeploymentArtifactPage.verifyArtifactsExistInTable(pathFile, vnfFile);
 592
 593             String vspName = createVendorSoftwareProduct.getName();
 594             DeploymentArtifactPage.clickCertifyButton(vspName);
 595             vspNames.put(vnfFile, vspName);
 596         }
 597
 598         // create service
 599         ServiceReqDetails serviceMetadata = ElementFactory.getDefaultService();
 600         ServiceUIUtils.createService(serviceMetadata);
 601         ServiceGeneralPage.getLeftMenu().moveToCompositionScreen();
 602         CanvasManager serviceCanvasManager = CanvasManager.getCanvasManager();
 603
 604         for (String vsp : vspNames.values()) {
 605             CompositionPage.searchForElement(vsp);
 606             CanvasElement vfElement = serviceCanvasManager.createElementOnCanvas(vsp);
 607             assertNotNull(vfElement);
 608         }
 609         ServiceVerificator.verifyNumOfComponentInstances(serviceMetadata, "0.1", vspNames.values().size(), getUser());
 610         File imageFilePath = GeneralUIUtils.takeScreenshot(null, SetupCDTest.getScreenshotFolder(), "Info_" + getExtendTest().getModel().getName());
 611         final String absolutePath = new File(SetupCDTest.getReportFolder()).toURI().relativize(imageFilePath.toURI()).getPath();
 612         SetupCDTest.getExtendTest().log(Status.INFO, "Three kinds of vMMSC are in canvas now." + getExtendTest().addScreenCaptureFromPath(absolutePath));
 613
 614         ServiceGeneralPage.clickSubmitForTestingButton(serviceMetadata.getName());
 615
 616         reloginWithNewRole(UserRoleEnum.TESTER);
 617         GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 618         TesterOperationPage.certifyComponent(serviceMetadata.getName());
 619
 620         reloginWithNewRole(UserRoleEnum.GOVERNOR);
 621         GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 622         GovernorOperationPage.approveService(serviceMetadata.getName());
 623
 624         reloginWithNewRole(UserRoleEnum.OPS);
 625         GeneralUIUtils.findComponentAndClick(serviceMetadata.getName());
 626         OpsOperationPage.distributeService();
 627         OpsOperationPage.displayMonitor();
 628
 629         List<WebElement> rowsFromMonitorTable = OpsOperationPage.getRowsFromMonitorTable();
 630         AssertJUnit.assertEquals(1, rowsFromMonitorTable.size());
 631
 632         OpsOperationPage.waitUntilArtifactsDistributed(0);
 633     }
 634
 635
 636     @Override
 637     protected UserRoleEnum getRole() {
 638         return UserRoleEnum.DESIGNER;
 639     }
 640
 641 }