gerrit.onap Code Review - sdc.git/blob

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