vid-automation/src/main/java/vid/automation/test/test/VidBaseTestCase.java

   1 package vid.automation.test.test;
   2
   3 import com.fasterxml.jackson.databind.ObjectMapper;
   4 import com.google.common.collect.ImmutableList;
   5 import org.apache.commons.lang3.StringUtils;
   6 import org.junit.Assert;
   7 import org.onap.simulator.presetGenerator.presets.BasePresets.BasePreset;
   8 import org.onap.simulator.presetGenerator.presets.aai.*;
   9 import org.onap.simulator.presetGenerator.presets.ecompportal_att.PresetGetSessionSlotCheckIntervalGet;
  10 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateServiceInstanceGen2;
  11 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOCreateServiceInstancePost;
  12 import org.onap.simulator.presetGenerator.presets.mso.PresetMSOOrchestrationRequestGet;
  13 import org.onap.simulator.presetGenerator.presets.sdc.PresetSDCGetServiceMetadataGet;
  14 import org.onap.simulator.presetGenerator.presets.sdc.PresetSDCGetServiceToscaModelGet;
  15 import org.openecomp.sdc.ci.tests.datatypes.UserCredentials;
  16 import org.openecomp.sdc.ci.tests.execute.setup.SetupCDTest;
  17 import org.openecomp.sdc.ci.tests.utilities.FileHandling;
  18 import org.openecomp.sdc.ci.tests.utilities.GeneralUIUtils;
  19 import org.openqa.selenium.By;
  20 import org.openqa.selenium.JavascriptExecutor;
  21 import org.openqa.selenium.WebElement;
  22 import org.testng.ITestContext;
  23 import org.testng.annotations.BeforeMethod;
  24 import org.testng.annotations.BeforeSuite;
  25 import org.testng.annotations.Test;
  26 import vid.automation.test.Constants;
  27 import vid.automation.test.infra.*;
  28 import vid.automation.test.model.Credentials;
  29 import vid.automation.test.model.User;
  30 import vid.automation.test.sections.*;
  31 import vid.automation.test.services.CategoryParamsService;
  32 import vid.automation.test.services.SimulatorApi;
  33 import vid.automation.test.services.UsersService;
  34 import vid.automation.test.utils.DB_CONFIG;
  35 import vid.automation.test.utils.TestConfigurationHelper;
  36
  37 import java.io.File;
  38 import java.lang.reflect.Method;
  39 import java.sql.*;
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.List;
  43 import java.util.Map;
  44 import java.util.stream.Collectors;
  45
  46 import static org.hamcrest.core.Is.is;
  47 import static org.testng.Assert.assertEquals;
  48 import static org.testng.AssertJUnit.fail;
  49
  50 public class VidBaseTestCase extends SetupCDTest{
  51
  52     protected final UsersService usersService = new UsersService();
  53     protected final CategoryParamsService categoryParamsService = new CategoryParamsService();
  54
  55     @Override
  56     protected UserCredentials getUserCredentials() {
  57         ObjectMapper mapper = new ObjectMapper().enableDefaultTyping();
  58         try {
  59             File configFile = FileHandling.getConfigFile("credentials");
  60             if(!configFile.exists()) {
  61                 String basePath = System.getProperty("BASE_PATH");
  62                 configFile = new File( basePath + File.separator + "conf" + File.separator + "credentials");
  63             }
  64             Credentials credentials = mapper.readValue(configFile, Credentials.class);
  65             User user = usersService.getUser(credentials.userId);
  66             return new UserCredentials(user.credentials.userId, user.credentials.password, credentials.userId, "", "");
  67         } catch (Exception e) {
  68             e.printStackTrace();
  69             return null;
  70         }
  71     }
  72
  73     @Override
  74     protected org.openecomp.sdc.ci.tests.datatypes.Configuration getEnvConfiguration() {
  75
  76         return TestConfigurationHelper.getEnvConfiguration();
  77     }
  78
  79     @BeforeMethod(alwaysRun = true)
  80     public void setBrowserBeforeTestIfDataProvider(Method method, ITestContext context, Object[] params) {
  81         // Hack to overcome limitations of SetupCDTest.setBrowserBeforeTest(java.lang.reflect.Method, org.testng.ITestContext)
  82         // that skips over dataProvided methods
  83         boolean emptyDataProvider = method.getAnnotation(Test.class).dataProvider().isEmpty();
  84         if (!emptyDataProvider) {
  85             final String testName = method.getName();
  86             final String listOfParams = Arrays.deepToString(params)
  87                     .replace('[', '(')
  88                     .replace(']', ')')
  89                     .replaceAll("[\\\\/:*?\"<>|]", "_");
  90
  91             setLog(testName+listOfParams);
  92         }
  93     }
  94
  95     @BeforeSuite(alwaysRun = true)
  96     public void screenShotsForReportPortal(){
  97         try {
  98             //ReportPortalListener.setScreenShotsProvider(new WebDriverScreenshotsProvider(getDriver()));
  99             System.out.println("Called to ReportPortalListener to set ScreenShotsProvider");
 100         } catch (Exception e) {
 101             e.printStackTrace();
 102         }
 103     }
 104
 105     @Override
 106     protected void loginToLocalSimulator(UserCredentials userCredentials) {
 107         LoginExternalPage.performLoginExternal(userCredentials);
 108     }
 109
 110     static public class ModelInfo {
 111         public final String modelVersionId;
 112         public final String modelInvariantId;
 113         public final String zipFileName;
 114
 115         public ModelInfo(String modelVersionId, String modelInvariantId, String zipFileName) {
 116             this.modelVersionId = modelVersionId;
 117             this.modelInvariantId = modelInvariantId;
 118             this.zipFileName = zipFileName;
 119         }
 120     }
 121
 122     protected void registerExpectationForLegacyServiceDeployment(String modelVersionId, String modelInvariantId, String zipFileName, String subscriberId) {
 123         registerExpectationForServiceDeployment(ServiceDeployment.LEGACY, ImmutableList.of(new ModelInfo(modelVersionId,modelInvariantId,zipFileName)), subscriberId);
 124     }
 125
 126     private enum ServiceDeployment {ASYNC, LEGACY}
 127
 128     protected void registerExpectationForServiceDeployment(ServiceDeployment serviceDeploymentOnMsoExpectations, List<ModelInfo> modelInfoList, String subscriberId) {
 129         List<BasePreset> presets = new ArrayList<>(Arrays.asList(
 130                 new PresetGetSessionSlotCheckIntervalGet(),
 131                 new PresetAAIGetSubscribersGet(),
 132                 new PresetAAIGetServicesGet(),
 133                 new PresetAAIGetSubDetailsGet(subscriberId),
 134                 new PresetAAIPostNamedQueryForViewEdit("f8791436-8d55-4fde-b4d5-72dd2cf13cfb"),
 135                 new PresetAAICloudRegionAndSourceFromConfigurationPut("9533-config-LB1113", "myRandomCloudRegionId"),
 136                 new PresetAAIGetPortMirroringSourcePorts("9533-config-LB1113", "myRandomInterfaceId", "i'm a port", true),
 137                 new PresetAAIGetNetworkZones(),
 138                 new PresetAAIGetTenants(),
 139                 new PresetAAIServiceDesignAndCreationPut(modelInfoList.stream().map(
 140                         x-> new PresetAAIServiceDesignAndCreationPut.ServiceModelIdentifiers(x.modelVersionId, x.modelInvariantId))
 141                         .collect(Collectors.toList()))
 142                 ));
 143
 144         modelInfoList.forEach(modelInfo -> {
 145             presets.add(new PresetSDCGetServiceMetadataGet(modelInfo.modelVersionId, modelInfo.modelInvariantId, modelInfo.zipFileName));
 146             presets.add(new PresetSDCGetServiceToscaModelGet(modelInfo.modelVersionId, modelInfo.zipFileName));
 147         });
 148
 149         switch (serviceDeploymentOnMsoExpectations) {
 150             case ASYNC:
 151                 presets.add(new PresetAAISearchNodeQueryEmptyResult());
 152                 presets.add(new PresetMSOCreateServiceInstanceGen2());
 153                 presets.add(new PresetMSOOrchestrationRequestGet("IN_PROGRESS"));
 154                 break;
 155             case LEGACY:
 156                 presets.add(new PresetMSOCreateServiceInstancePost());
 157                 presets.add(new PresetMSOOrchestrationRequestGet());
 158                 break;
 159         }
 160
 161         SimulatorApi.registerExpectationFromPresets(presets, SimulatorApi.RegistrationStrategy.CLEAR_THEN_SET);
 162     }
 163
 164     protected void relogin(Credentials credentials) throws Exception {
 165         // `getWindowTest().getPreviousUser()` is SetupCDTest's state of previous user used
 166         if (!credentials.userId.equals(getWindowTest().getPreviousUser())) {
 167             UserCredentials userCredentials = new UserCredentials(credentials.userId,
 168                     credentials.password, "", "", "");
 169             reloginWithNewRole(userCredentials);
 170         } else {
 171             System.out.println(String.format("VidBaseTestCase.relogin() " +
 172                     "-> '%s' is already logged in, so skipping", credentials.userId));
 173         }
 174     }
 175
 176     /**
 177      * Validates that permitted options are enabled and others are disabled.
 178      *
 179      * @param permittedItems           the list of permitted items.
 180      * @param dropdownOptionsClassName the class name of the specific dropdown options.
 181      * @return true, if all dropdown options disabled state is according to the permissions.
 182      */
 183     protected void assertDropdownPermittedItemsByValue(ArrayList<String> permittedItems, String dropdownOptionsClassName) {
 184         assertDropdownPermittedItemsByValue(permittedItems, dropdownOptionsClassName, "value");
 185     }
 186
 187     protected void assertDropdownPermittedItemsByLabel(ArrayList<String> permittedItems, String dropdownOptionsClassName) {
 188         assertDropdownPermittedItemsByValue(permittedItems, dropdownOptionsClassName, "label");
 189     }
 190
 191     /**
 192      * Validates that permitted options are enabled and others are disabled.
 193      *
 194      * @param permittedItems           the list of permitted items.
 195      * @param dropdownOptionsClassName the class name of the specific dropdown options.
 196      * @param attribute
 197      * @return true, if all dropdown options disabled state is according to the permissions.
 198      */
 199     private void assertDropdownPermittedItemsByValue(ArrayList<String> permittedItems, String dropdownOptionsClassName, String attribute) {
 200         GeneralUIUtils.ultimateWait();
 201         List<WebElement> optionsList =
 202                 GeneralUIUtils.getWebElementsListBy(By.className(dropdownOptionsClassName), 30);
 203         for (WebElement option :
 204                 optionsList) {
 205             String optionValue = option.getAttribute(attribute);
 206             if ((option.isEnabled() && !permittedItems.contains(optionValue)) ||
 207                     !option.isEnabled() && permittedItems.contains(optionValue)) {
 208                 fail(Constants.DROPDOWN_PERMITTED_ASSERT_FAIL_MESSAGE);
 209             }
 210         }
 211     }
 212
 213     protected void assertAllIsPermitted(String dropdownOptionsClassName) {
 214         GeneralUIUtils.ultimateWait();
 215         List<WebElement> optionsList =
 216                 GeneralUIUtils.getWebElementsListBy(By.className(dropdownOptionsClassName), 30);
 217         for (WebElement option :
 218                 optionsList) {
 219             String optionValue = option.getAttribute("value");
 220             if (!option.isEnabled()) {
 221                 fail(Constants.DROPDOWN_PERMITTED_ASSERT_FAIL_MESSAGE);
 222             }
 223         }
 224     }
 225
 226     protected void assertDropdownPermittedItemsByName(ArrayList<String> permittedItems, String dropdownOptionsClassName) {
 227         GeneralUIUtils.ultimateWait();
 228         List<WebElement> optionsList =
 229                 GeneralUIUtils.getWebElementsListBy(By.className(dropdownOptionsClassName), 30);
 230         for (WebElement option :
 231                 optionsList) {
 232             String optionText = option.getText();
 233             if ((option.isEnabled() && !permittedItems.contains(optionText)) ||
 234                     !option.isEnabled() && permittedItems.contains(optionText)) {
 235                 fail(Constants.DROPDOWN_PERMITTED_ASSERT_FAIL_MESSAGE);
 236             }
 237         }
 238     }
 239
 240     protected void assertViewEditButtonState(String expectedButtonText, String UUID) {
 241         WebElement viewEditWebElement = GeneralUIUtils.getWebElementByTestID(Constants.VIEW_EDIT_TEST_ID_PREFIX + UUID, 100);
 242         Assert.assertEquals(expectedButtonText, viewEditWebElement.getText());
 243         GeneralUIUtils.ultimateWait();
 244     }
 245
 246
 247     protected void addNetwork(Map<String, String> metadata,String instanceName, String name, String lcpRegion, String productFamily,String platform, String lineOfBusiness, String tenant, String suppressRollback,
 248                                String legacyRegion, ArrayList<String> permittedTenants) {
 249         ViewEditPage viewEditPage = new ViewEditPage();
 250
 251         viewEditPage.selectNetworkToAdd(name);
 252         assertModelInfo(metadata, false);
 253         viewEditPage.setInstanceName(instanceName);
 254         viewEditPage.selectLCPRegion(lcpRegion);
 255         viewEditPage.selectProductFamily(productFamily);
 256         viewEditPage.selectLineOfBusiness(lineOfBusiness);
 257         assertDropdownPermittedItemsByValue(permittedTenants, Constants.ViewEdit.TENANT_OPTION_CLASS);
 258         viewEditPage.selectTenant(tenant);
 259
 260         viewEditPage.selectSuppressRollback(suppressRollback);
 261         viewEditPage.selectPlatform(platform);
 262         //viewEditPage.setLegacyRegion(legacyRegion);
 263
 264         viewEditPage.clickConfirmButton();
 265         viewEditPage.assertMsoRequestModal(Constants.ViewEdit.MSO_SUCCESSFULLY_TEXT);
 266         viewEditPage.clickCloseButton();
 267         GeneralUIUtils.ultimateWait();
 268     }
 269
 270     void assertSuccessfulVNFCreation() {
 271         boolean byText = GeneralUIUtils.findAndWaitByText(Constants.ViewEdit.VNF_CREATED_SUCCESSFULLY_TEXT, 100);
 272         Assert.assertTrue(Constants.ViewEdit.VNF_CREATION_FAILED_MESSAGE, byText);
 273     }
 274
 275     void assertSuccessfulPNFAssociation() {
 276         //TODO
 277         boolean byText = GeneralUIUtils.findAndWaitByText(Constants.PnfAssociation.PNF_ASSOCIATED_SUCCESSFULLY_TEXT, 100);
 278         Assert.assertTrue(Constants.PnfAssociation.PNF_ASSOCIATED_FAILED_MESSAGE, byText);
 279     }
 280     void assertSuccessfulVolumeGroupCreation() {
 281         boolean byText = GeneralUIUtils.findAndWaitByText(Constants.ViewEdit.VOLUME_GROUP_CREATED_SUCCESSFULLY_TEXT, 100);
 282         Assert.assertTrue(Constants.ViewEdit.VOLUME_GROUP_CREATION_FAILED_MESSAGE, byText);
 283     }
 284
 285     void assertSuccessfulVFModuleCreation() {
 286         boolean byText = GeneralUIUtils.findAndWaitByText(Constants.ViewEdit.VF_MODULE_CREATED_SUCCESSFULLY_TEXT, 100);
 287         Assert.assertTrue(Constants.ViewEdit.VF_MODULE_CREATION_FAILED_MESSAGE, byText);
 288     }
 289
 290     void goToExistingInstanceById(String instanceUUID) {
 291         SearchExistingPage searchExistingPage = searchExistingInstanceById(instanceUUID);
 292         assertViewEditButtonState( Constants.VIEW_EDIT_BUTTON_TEXT, instanceUUID);
 293
 294         searchExistingPage.clickEditViewByInstanceId(instanceUUID);
 295         GeneralUIUtils.ultimateWait();
 296     }
 297
 298     void searchForExistingInstanceByIdReadonlyMode(String instanceUUID) {
 299         searchExistingInstanceById(instanceUUID);
 300         assertViewEditButtonState( Constants.VIEW_BUTTON_TEXT, instanceUUID);
 301     }
 302
 303     SearchExistingPage searchExistingInstanceById(String instanceUUID){
 304         SearchExistingPage searchExistingPage = new SearchExistingPage();
 305         SideMenu.navigateToSearchExistingPage();
 306         searchExistingPage.searchForInstanceByUuid(instanceUUID);
 307         return searchExistingPage;
 308     }
 309
 310
 311     void goToExistingInstanceByIdNoWait(String instanceUUID) {
 312         SearchExistingPage searchExistingPage = searchExistingInstanceById(instanceUUID);
 313         searchExistingPage.clickEditViewByInstanceId(instanceUUID);
 314     }
 315
 316     void resumeVFModule(String vfModuleName, String lcpRegion, String tenant, String legacyRegion, ArrayList<String> permittedTenants){
 317         ViewEditPage viewEditPage = new ViewEditPage();
 318         viewEditPage.clickResumeButton(vfModuleName);
 319         viewEditPage.selectLCPRegion(lcpRegion);
 320         assertDropdownPermittedItemsByValue(permittedTenants, Constants.ViewEdit.TENANT_OPTION_CLASS);
 321         viewEditPage.selectTenant(tenant);
 322         viewEditPage.setLegacyRegion(legacyRegion);
 323         viewEditPage.clickConfirmButtonInResumeDelete();
 324         assertSuccessfulVFModuleCreation();
 325         viewEditPage.clickCommitCloseButton();
 326         GeneralUIUtils.ultimateWait();
 327     }
 328
 329     void goToExistingInstanceByName(String instanceName) {
 330         SearchExistingPage searchExistingPage = new SearchExistingPage();
 331         SideMenu.navigateToSearchExistingPage();
 332         searchExistingPage.searchForInstanceByName(instanceName);
 333         WebElement instanceIdRow = GeneralUIUtils.getWebElementByTestID(Constants.INSTANCE_ID_FOR_NAME_TEST_ID_PREFIX + instanceName, 30);
 334         String instanceId = instanceIdRow.getText();
 335         assertViewEditButtonState( Constants.VIEW_EDIT_BUTTON_TEXT, instanceId);
 336         searchExistingPage.clickEditViewByInstanceId(instanceId);
 337         GeneralUIUtils.ultimateWait();
 338     }
 339
 340     String confirmFilterById(String instanceName, String instanceUUID) {
 341         WebElement filter = GeneralUIUtils.getWebElementByTestID(Constants.FILTER_SUBSCRIBER_DETAILS_ID, 30);
 342         filter.sendKeys(instanceUUID);
 343
 344         WebElement firstElement = GeneralUIUtils.getWebElementByTestID(Constants.INSTANCE_ID_FOR_NAME_TEST_ID_PREFIX + instanceName, 30);
 345         String filteredId = firstElement.getText();
 346         Assert.assertTrue(filteredId.equals(instanceUUID));
 347         return filteredId;
 348     }
 349
 350     void goToExistingInstanceBySubscriber(String subscriberName,String instanceName,String instanceUUID) {
 351         SearchExistingPage searchExistingPage = new SearchExistingPage();
 352         SideMenu.navigateToSearchExistingPage();
 353         SelectOption.byIdAndVisibleText(Constants.EditExistingInstance.SELECT_SUBSCRIBER, subscriberName);
 354         searchExistingPage.clickSubmitButton();
 355         GeneralUIUtils.ultimateWait();
 356         confirmFilterById(instanceName, instanceUUID);
 357         searchExistingPage.clickEditViewByInstanceId(instanceUUID);
 358         GeneralUIUtils.ultimateWait();
 359     }
 360
 361     void selectMsoTestApiOption(String msoTestApiOption) {
 362         final String id = "selectTestApi";
 363         final String sectionId = "selectTestApiSection";
 364
 365         SideMenu.navigateToWelcomePage();
 366
 367         if (Exists.byId(sectionId)) {
 368             final JavascriptExecutor javascriptExecutor = (JavascriptExecutor) GeneralUIUtils.getDriver();
 369             javascriptExecutor.executeScript(
 370                     "document.getElementById('" + sectionId + "').style.visibility = 'inherit';"
 371             );
 372
 373             if (null == SelectOption.byIdAndVisibleText(id, msoTestApiOption)) {
 374                 Assert.fail("selectMsoTestApiOptionIfPossible couldnt apply " + msoTestApiOption);
 375             }
 376         }
 377     }
 378
 379     protected void assertModelInfo(Map<String, String> expectedMetadata, boolean withPrefix) {
 380         Wait.angularHttpRequestsLoaded();
 381         GeneralUIUtils.ultimateWait();
 382         for (Map.Entry<String, String> item: expectedMetadata.entrySet()) {
 383             assertMetadataItem(item.getKey(), item.getValue(), withPrefix);
 384         }
 385     }
 386
 387     protected <T> void setNewInstance_leftPane_assertModelDataCorrect(Map<String, String> modelKeyToDataTestsIdMap, String prefix, T model) {
 388         modelKeyToDataTestsIdMap.forEach((fieldName, dataTestsId) -> {
 389             WebElement webElement = Get.byTestId(prefix + dataTestsId);
 390             assertEquals(webElement.getText(), getServiceFieldByName(fieldName, model));
 391         });
 392     }
 393
 394     protected <T> void setNewInstance_leftPane_assertModelLabelsVisibilityCorrect(Map<String, String> modelKeyToDataTestsIdMap, String prefix, T model) {
 395         modelKeyToDataTestsIdMap.forEach((fieldName, dataTestsId) -> {
 396             WebElement webElement = Get.byTestId(prefix + dataTestsId);
 397             String field = getServiceFieldByName(fieldName, model);
 398             assertEquals(webElement.isDisplayed(), !(StringUtils.isEmpty(field)) , dataTestsId + " label shouldn't appear when " + fieldName + " is empty");
 399         });
 400     }
 401
 402     private <T> String getServiceFieldByName(String name, T model) {
 403         try {
 404             return model.getClass().getField(name).get(model).toString();
 405         } catch (IllegalAccessException | NoSuchFieldException e) {
 406             throw new RuntimeException(e);
 407         }
 408     }
 409
 410     private void assertMetadataItem(String keyTestId, String value, boolean withPrefix) {
 411         String elementTestId = (withPrefix ? Constants.ServiceModelInfo.INFO_TEST_ID_PREFIX:"") + keyTestId;
 412         String infoItemText = GeneralUIUtils.getWebElementByTestID(elementTestId, 60).getText();
 413         Assert.assertThat(String.format(Constants.ServiceModelInfo.METADETA_ERROR_MESSAGE, elementTestId),  infoItemText, is(value));
 414     }
 415
 416     public DeployMacroDialogBase getMacroDialog(){
 417         if (Features.FLAG_ASYNC_INSTANTIATION.isActive()) {
 418             VidBasePage vidBasePage =new VidBasePage();
 419             vidBasePage.goToIframe();
 420             return new DeployMacroDialog();
 421         }
 422         else
 423             return  new DeployMacroDialogOld();
 424     }
 425
 426     protected void loadServicePopup(String zipFileName, String modelVersionId ) {
 427         String modelInvariantId = "e49fbd11-e60c-4a8e-b4bf-30fbe8f4fcc0";
 428         String subscriberId = "e433710f-9217-458d-a79d-1c7aff376d89";
 429         registerExpectationForServiceDeployment(
 430                 ServiceDeployment.ASYNC,
 431                 ImmutableList.of(
 432                     new ModelInfo(modelVersionId, modelInvariantId, zipFileName),
 433                     new ModelInfo("f4d84bb4-a416-4b4e-997e-0059973630b9", "598e3f9e-3244-4d8f-a8e0-0e5d7a29eda9", "service-AdiodVmxVpeBvService488-csar-annotations.zip")
 434                 ),
 435                 subscriberId);
 436         SideMenu.navigateToBrowseASDCPage();
 437         GeneralUIUtils.ultimateWait();
 438         loadServicePopupOnBrowseASDCPage(modelVersionId);
 439     }
 440
 441     protected void loadServicePopupOnBrowseASDCPage(String modelVersionId ) {
 442         DeployMacroDialog deployMacroDialog = new DeployMacroDialog();
 443         deployMacroDialog.goOutFromIframe();
 444         deployMacroDialog.clickDeployServiceButtonByServiceUUID(modelVersionId);
 445         deployMacroDialog.goToIframe();
 446         GeneralUIUtils.ultimateWait();
 447         Wait.byText("Model version");
 448     }
 449
 450     public void assertSetButtonDisabled(String buttonTestId) {
 451         WebElement webElement = Get.byTestId(buttonTestId);
 452         org.testng.Assert.assertFalse(webElement.isEnabled(), "Set button should be disabled if not all mandatory fields are field.");
 453     }
 454
 455     public void assertSetButtonEnabled(String buttonTestId) {
 456
 457         WebElement webElement = Get.byTestId(buttonTestId);
 458         org.testng.Assert.assertTrue(webElement.isEnabled(), "Set button should be enabled if all mandatory fields are field.");
 459     }
 460
 461     public void assertElementDisabled(String id) {
 462         WebElement webElement = Get.byId(id);
 463         assert webElement != null;
 464         org.testng.Assert.assertFalse(webElement.isEnabled(), "field should be disabled if the field it depends on was not selected yet.");
 465     }
 466
 467     protected int getUserIdNumberFromDB(User user) {
 468         try (Connection connection = DriverManager.getConnection(DB_CONFIG.url, DB_CONFIG.username, DB_CONFIG.password)) {
 469             Statement stmt = connection.createStatement();
 470             ResultSet userIdResultSet;
 471             userIdResultSet = stmt.executeQuery("SELECT USER_ID FROM fn_user where LOGIN_ID = '" + user.credentials.userId + "'");
 472             Assert.assertTrue("Exactly one user should be found", userIdResultSet.next());
 473             int userId = userIdResultSet.getInt("USER_ID");
 474             Assert.assertFalse("There are more than one user for id " + userId, userIdResultSet.next());
 475             return userId;
 476         } catch (SQLException e) {
 477             throw new IllegalStateException("Cannot connect the database!", e);
 478         }
 479     }
 480
 481     protected List<Integer> getRoleIDsAssignedToUser(int userId) {
 482         try (Connection connection = DriverManager.getConnection(DB_CONFIG.url, DB_CONFIG.username, DB_CONFIG.password)) {
 483             Statement stmt = connection.createStatement();
 484             ResultSet userRolesResultSet;
 485             userRolesResultSet = stmt.executeQuery("SELECT ROLE_ID FROM fn_user_role where USER_ID = '" + userId + "' order by ROLE_ID");
 486
 487             List<Integer> userRoles = new ArrayList<Integer>();
 488             while (userRolesResultSet.next()) {
 489                 userRoles.add(userRolesResultSet.getInt("ROLE_ID"));
 490             }
 491             return userRoles;
 492         } catch (SQLException e) {
 493             throw new IllegalStateException("Cannot connect the database!", e);
 494         }
 495     }
 496
 497     protected void navigateToViewEditPageOfuspVoiceVidTest444(String aaiModelVersionId) {
 498         VidBasePage vidBasePage = new VidBasePage();
 499         SideMenu.navigateToWelcomePage();
 500         vidBasePage.navigateTo("serviceModels.htm#/instantiate?" +
 501                 "subscriberId=e433710f-9217-458d-a79d-1c7aff376d89&" +
 502                 "subscriberName=USP%20VOICE&" +
 503                 "serviceType=VIRTUAL%20USP&" +
 504                 "serviceInstanceId=3f93c7cb-2fd0-4557-9514-e189b7b04f9d&" +
 505                 "aaiModelVersionId=" + aaiModelVersionId + "&" +
 506                 "isPermitted=true");
 507         GeneralUIUtils.ultimateWait();
 508     }
 509 }