source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.web.test.parent;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  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,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.web.test.tools.ArchivaSeleniumExecutionRule;
  23 import org.apache.archiva.web.test.tools.WebdriverUtility;
  24 import org.junit.Assert;
  25 import org.junit.Rule;
  26
  27 import java.io.File;
  28 import java.nio.file.Path;
  29 import java.text.SimpleDateFormat;
  30 import java.util.Date;
  31 import java.util.Iterator;
  32 import java.util.Map;
  33 import java.util.Map.Entry;
  34 import java.util.Properties;
  35 import java.util.concurrent.TimeUnit;
  36 import java.util.function.Function;
  37
  38 import org.openqa.selenium.*;
  39 import org.openqa.selenium.htmlunit.HtmlUnitDriver;
  40 import org.openqa.selenium.interactions.Actions;
  41 import org.openqa.selenium.support.ui.ExpectedConditions;
  42 import org.openqa.selenium.support.ui.FluentWait;
  43 import org.openqa.selenium.support.ui.Select;
  44 import org.openqa.selenium.support.ui.WebDriverWait;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 /**
  49  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  50  *
  51  */
  52
  53 public abstract class AbstractSeleniumTest
  54 {
  55     private final Logger logger = LoggerFactory.getLogger( getClass() );
  56
  57     @Rule
  58     public ArchivaSeleniumExecutionRule archivaSeleniumExecutionRule = new ArchivaSeleniumExecutionRule();
  59
  60     public String browser = System.getProperty( "browser" );
  61
  62     public String baseUrl =
  63         "http://localhost:" + System.getProperty( "container.http.port" ) + "/archiva/index.html?request_lang=en";
  64
  65     public int maxWaitTimeInMs = Integer.getInteger( "maxWaitTimeInMs" );
  66
  67     public String seleniumHost = System.getProperty( "seleniumHost", "localhost" );
  68
  69     public int seleniumPort = Integer.getInteger( "seleniumPort", 4444 );
  70
  71     public boolean remoteSelenium = Boolean.parseBoolean( System.getProperty( "seleniumRemote", "false" ) );
  72
  73     WebDriver webDriver = null;
  74
  75     public Properties p;
  76
  77     /**
  78      * this method is called by the Rule before executing a test
  79      *
  80      * @throws Exception
  81      */
  82     public void open()
  83         throws Exception
  84     {
  85         p = new Properties();
  86         p.load( this.getClass().getClassLoader().getResourceAsStream( "test.properties" ) );
  87
  88         baseUrl = WebdriverUtility.getBaseUrl()+"/index.html?request_lang=en";
  89
  90         open( baseUrl, browser, seleniumHost, seleniumPort, maxWaitTimeInMs, remoteSelenium );
  91         assertAdminCreated();
  92     }
  93
  94     /**
  95      * this method is called by the Rule after executing a tests
  96      */
  97     public void close()
  98     {
  99         getWebDriver().close();
 100     }
 101
 102     /**
 103      * Initialize selenium
 104      */
 105     public void open( String baseUrl, String browser, String seleniumHost, int seleniumPort, int maxWaitTimeInMs, boolean remoteSelenium)
 106         throws Exception
 107     {
 108         try
 109         {
 110             if ( getWebDriver() == null )
 111             {
 112                 WebDriver driver = WebdriverUtility.newWebDriver(browser, seleniumHost, seleniumPort, remoteSelenium);
 113                 // selenium.start();
 114                 // selenium.setTimeout( Integer.toString( maxWaitTimeInMs ) );
 115                 this.webDriver = driver;
 116             }
 117         }
 118         catch ( Exception e )
 119         {
 120             // yes
 121             System.out.print( e.getMessage() );
 122             e.printStackTrace();
 123         }
 124     }
 125
 126     public void assertAdminCreated()
 127         throws Exception
 128     {
 129         initializeArchiva( baseUrl, browser, maxWaitTimeInMs, seleniumHost, seleniumPort, remoteSelenium );
 130     }
 131
 132     public void initializeArchiva( String baseUrl, String browser, int maxWaitTimeInMs, String seleniumHost,
 133                                    int seleniumPort, boolean remoteSelenium)
 134         throws Exception
 135     {
 136
 137         open( baseUrl, browser, seleniumHost, seleniumPort, maxWaitTimeInMs, remoteSelenium);
 138
 139         getWebDriver().get(baseUrl);
 140         WebDriverWait wait = new WebDriverWait(getWebDriver(),30);
 141         wait.until(ExpectedConditions.presenceOfElementLocated(By.id("topbar-menu")));
 142
 143         wait = new WebDriverWait( getWebDriver(), 20 );
 144         Boolean found = wait.until( ExpectedConditions.or(
 145                     ExpectedConditions.visibilityOfElementLocated(By.id("create-admin-link-a")),
 146                             ExpectedConditions.visibilityOfElementLocated(By.id("login-link-a"))));
 147         if (found)
 148         {
 149
 150             WebElement adminLink = getWebDriver().findElement( By.id( "create-admin-link-a" ) );
 151             WebElement loginLink = getWebDriver().findElement( By.id( "login-link-a" ) );
 152
 153             // if not admin user created create one
 154             if ( adminLink != null && adminLink.isDisplayed() )
 155             {
 156
 157                 Assert.assertFalse( isElementVisible( "login-link-a" ) );
 158                 Assert.assertFalse( isElementVisible( "register-link-a" ) );
 159                 // skygo need to set to true for passing is that work as expected ?
 160                 adminLink.click();
 161                 wait = new WebDriverWait( getWebDriver(), 10 );
 162                 wait.until( ExpectedConditions.visibilityOfElementLocated( By.id( "user-create" ) ) );
 163                 assertCreateAdmin();
 164                 String fullname = getProperty( "ADMIN_FULLNAME" );
 165                 String username = getAdminUsername();
 166                 String mail = getProperty( "ADMIN_EMAIL" );
 167                 String password = getProperty( "ADMIN_PASSWORD" );
 168                 submitAdminData( fullname, mail, password );
 169                 assertUserLoggedIn( username );
 170                 clickLinkWithLocator( "logout-link-a", false );
 171             }
 172                  else if ( loginLink != null && loginLink.isDisplayed() )
 173             {
 174                 Assert.assertTrue( isElementVisible( "login-link-a" ) );
 175                 Assert.assertTrue( isElementVisible( "register-link-a" ) );
 176                 login( getAdminUsername(), getAdminPassword() );
 177             }
 178         }
 179
 180     }
 181
 182     public WebDriver getWebDriver() {
 183         return this.webDriver;
 184     }
 185
 186     protected String getProperty( String key )
 187     {
 188         return p.getProperty( key );
 189     }
 190
 191     public String getAdminUsername()
 192     {
 193         String adminUsername = getProperty( "ADMIN_USERNAME" );
 194         return adminUsername;
 195     }
 196
 197     public String getAdminPassword()
 198     {
 199         String adminPassword = getProperty( "ADMIN_PASSWORD" );
 200         return adminPassword;
 201     }
 202
 203     public void submitAdminData( String fullname, String email, String password )
 204     {
 205         setFieldValue( "fullname", fullname );
 206         setFieldValue( "email", email );
 207         setFieldValue( "password", password );
 208         setFieldValue( "confirmPassword", password );
 209         clickButtonWithLocator( "user-create-form-register-button" , false);
 210     }
 211
 212     public void login( String username, String password )
 213     {
 214         login( username, password, true, "Login Page" );
 215     }
 216
 217     public void login( String username, String password, boolean valid, String assertReturnPage )
 218     {
 219         if ( isElementVisible( "login-link-a" ) )//isElementPresent( "loginLink" ) )
 220         {
 221             goToLoginPage();
 222
 223             submitLoginPage( username, password, false, valid, assertReturnPage );
 224         }
 225         if ( valid )
 226         {
 227             assertUserLoggedIn( username );
 228         }
 229     }
 230
 231     // Go to Login Page
 232     public void goToLoginPage()
 233     {
 234         logger.info("Goto login page");
 235         getWebDriver().get( baseUrl );
 236         WebDriverWait wait = new WebDriverWait(getWebDriver(),30);
 237         wait.until(ExpectedConditions.presenceOfElementLocated(By.id("topbar-menu")));
 238         wait.until(ExpectedConditions.or(ExpectedConditions.visibilityOfElementLocated(By.id("logout-link")),
 239                 ExpectedConditions.visibilityOfElementLocated(By.id("login-link-a"))));
 240
 241         // are we already logged in ?
 242         if ( isElementVisible( "logout-link" ) ) //isElementPresent( "logoutLink" ) )
 243         {
 244             logger.info("Logging out ");
 245             // so logout
 246             clickLinkWithLocator( "logout-link-a", false );
 247         }
 248         wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("login-link-a")));
 249         clickLinkWithLocator( "login-link-a", false );
 250         // This is a workaround for bug with HTMLUnit. The display attribute of the
 251         // login dialog is not changed via the click.
 252         // TODO: Check after changing jquery, bootstrap or htmlunit version
 253         if (getWebDriver() instanceof HtmlUnitDriver)
 254         {
 255             ( (JavascriptExecutor) getWebDriver() ).executeScript( "$('#modal-login').show();" );
 256         }
 257         // END OF WORKAROUND
 258         wait = new WebDriverWait(getWebDriver(),20);
 259         wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("modal-login")));
 260         assertLoginModal();
 261     }
 262
 263
 264     public void assertLoginModal()
 265     {
 266         assertElementPresent( "user-login-form" );
 267         Assert.assertTrue( isElementVisible( "register-link" ) );
 268         Assert.assertTrue( isElementVisible("user-login-form-username" ));
 269         Assert.assertTrue( isElementVisible("user-login-form-password" ));
 270         assertButtonWithIdPresent( "modal-login-ok" );
 271         Assert.assertTrue( isElementVisible( "modal-login-ok" ));
 272     }
 273
 274
 275     public void submitLoginPage( String username, String password )
 276     {
 277         submitLoginPage( username, password, false, true, "Login Page" );
 278     }
 279
 280     public void submitLoginPage( String username, String password, boolean validUsernamePassword )
 281     {
 282         submitLoginPage( username, password, false, validUsernamePassword, "Login Page" );
 283     }
 284
 285     public void submitLoginPage( String username, String password, boolean rememberMe, boolean validUsernamePassword,
 286                                  String assertReturnPage )
 287     {
 288         logger.info("Activating login form");
 289         // clickLinkWithLocator( "login-link-a", false);
 290         WebDriverWait wait = new WebDriverWait(getWebDriver(),5);
 291         WebElement usernameField = wait.until(ExpectedConditions.visibilityOf(getWebDriver().findElement(By.id("user-login-form-username"))));
 292         wait = new WebDriverWait(getWebDriver(),5);
 293         WebElement passwordField = wait.until(ExpectedConditions.visibilityOf(getWebDriver().findElement(By.id("user-login-form-password"))));
 294         wait = new WebDriverWait(getWebDriver(),5);
 295         WebElement button = wait.until(ExpectedConditions.elementToBeClickable(By.id("modal-login-ok")));
 296         usernameField.sendKeys(username);
 297         passwordField.sendKeys(password);
 298         /*
 299         if ( rememberMe )
 300         {
 301             checkField( "rememberMe" );
 302         }*/
 303
 304         button.click();
 305         if ( validUsernamePassword )
 306         {
 307             assertUserLoggedIn( username );
 308         }
 309         /*
 310         else
 311         {
 312             if ( "Login Page".equals( assertReturnPage ) )
 313             {
 314                 assertLoginPage();
 315             }
 316             else
 317             {
 318                 assertPage( assertReturnPage );
 319             }
 320         }*/
 321     }
 322
 323     // *******************************************************
 324     // Auxiliar methods. This method help us and simplify test.
 325     // *******************************************************
 326
 327     protected void assertUserLoggedIn( String username )
 328     {
 329         WebDriverWait wait = new WebDriverWait(getWebDriver(), 10);
 330         wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("logout-link")));
 331         Assert.assertFalse( isElementVisible( "login-link" ) );
 332         Assert.assertFalse( isElementVisible( "register-link" ) );
 333         Assert.assertFalse( isElementVisible( "create-admin-link" ) );
 334     }
 335
 336     public void assertCreateAdmin()
 337     {
 338         assertElementPresent( "user-create" );
 339         assertFieldValue( "admin", "username" );
 340         assertElementPresent( "fullname" );
 341         assertElementPresent( "password" );
 342         assertElementPresent( "confirmPassword" );
 343         assertElementPresent( "email" );
 344     }
 345
 346     public void assertFieldValue( String fieldValue, String fieldName )
 347     {
 348         assertElementPresent( fieldName );
 349         Assert.assertEquals( fieldValue, findElement(fieldName ).getAttribute( "value") );
 350     }
 351
 352     public void assertPage( String title )
 353     {
 354         Assert.assertEquals( title,  getTitle());
 355     }
 356
 357     public String getTitle()
 358     {
 359         // Collapse spaces
 360         return getWebDriver().getTitle().replaceAll( "[ \n\r]+", " " );
 361     }
 362
 363     public String getHtmlContent()
 364     {
 365         return getWebDriver().getPageSource();
 366     }
 367
 368     public String getText( String locator )
 369     {
 370         return findElement(locator ).getText();
 371     }
 372
 373     public void assertTextPresent( String text )
 374     {
 375         Assert.assertTrue( "'" + text + "' isn't present.", getWebDriver().getPageSource().contains( text ) );
 376     }
 377
 378
 379     public void assertTextNotPresent( String text )
 380     {
 381         Assert.assertFalse( "'" + text + "' is present.", isTextPresent( text ) );
 382     }
 383
 384     public void assertElementPresent( String elementLocator )
 385     {
 386         Assert.assertTrue( "'" + elementLocator + "' isn't present.", isElementPresent( elementLocator ) );
 387     }
 388
 389     public void assertElementNotPresent( String elementLocator )
 390     {
 391         Assert.assertFalse( "'" + elementLocator + "' is present.", isElementPresent( elementLocator ) );
 392     }
 393
 394     public void assertLinkPresent( String text )
 395     {
 396         Assert.assertTrue( "The link '" + text + "' isn't present.", isElementPresent( "//*[text()='" + text+"']//ancestor::a"  ) );
 397     }
 398
 399     public void assertLinkNotPresent( String text )
 400     {
 401         Assert.assertFalse( "The link('" + text + "' is present.", isElementPresent( "//*[text()='" + text+"']//ancestor::a" ) );
 402     }
 403
 404     public void assertLinkNotVisible( String text )
 405     {
 406         Assert.assertFalse( "The link('" + text + "' is visible.", isElementVisible( "//*[text()='" + text+"']//ancestor::a"  ) );
 407     }
 408
 409     public void assertLinkVisible( String text )
 410     {
 411         Assert.assertTrue( "The link('" + text + "' is not visible.", isElementVisible( "//*[text()='" + text+"']//ancestor::a" ) );
 412     }
 413
 414     public void assertImgWithAlt( String alt )
 415     {
 416         assertElementPresent( "/¯img[@alt='" + alt + "']" );
 417     }
 418
 419     public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 420     {
 421         String locator = "//tr[" + row + "]/td[" + column + "]/";
 422         locator += isALink ? "a/" : "";
 423         locator += "img[@alt='" + alt + "']";
 424
 425         assertElementPresent( locator );
 426     }
 427
 428     public void assertImgWithAltNotPresent( String alt )
 429     {
 430         assertElementNotPresent( "/¯img[@alt='" + alt + "']" );
 431     }
 432
 433
 434
 435     public boolean isTextPresent( String text )
 436     {
 437         return getWebDriver().getPageSource().contains(text);
 438     }
 439
 440     public boolean isLinkPresent( String text )
 441     {
 442         return isElementPresent( "//*[text()='" + text +"']//ancestor::a" );
 443     }
 444
 445     public boolean isElementPresent( String locator )
 446     {
 447         try
 448         {
 449             return findElement(locator ) != null;
 450         } catch (Exception e) {
 451             return false;
 452         }
 453     }
 454
 455     public boolean isElementVisible(String locator )
 456     {
 457         try {
 458             return findElement(locator).isDisplayed();
 459         } catch (Exception e) {
 460             return false;
 461         }
 462     }
 463
 464
 465     public void waitPage()
 466     {
 467         // TODO define a smaller maxWaitTimeJsInMs for wait javascript response for browser side validation
 468         //getSelenium().w .wait( Long.parseLong( maxWaitTimeInMs ) );
 469         //getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 470         // http://jira.openqa.org/browse/SRC-302
 471         // those hack looks to break some tests :-(
 472         // getSelenium().waitForCondition( "selenium.isElementPresent('document.body');", maxWaitTimeInMs );
 473         //getSelenium().waitForCondition( "selenium.isElementPresent('footer');", maxWaitTimeInMs );
 474         //getSelenium().waitForCondition( "selenium.browserbot.getCurrentWindow().document.getElementById('footer')",
 475         //                                maxWaitTimeInMs );
 476         // so the only hack is to not use a too small wait time
 477
 478         try
 479         {
 480             Thread.sleep( maxWaitTimeInMs );
 481         }
 482         catch ( InterruptedException e )
 483         {
 484             throw new RuntimeException( "issue on Thread.sleep : " + e.getMessage(), e );
 485         }
 486     }
 487
 488     public String getFieldValue( String fieldName )
 489     {
 490         return findElement(fieldName ).getAttribute( "value" );
 491     }
 492
 493
 494     public void selectValue( String locator, String value )
 495     {
 496         WebElement element = findElement(locator );
 497         Select select = new Select(element);
 498         select.selectByValue( value );
 499     }
 500
 501     public WebElement findElement(String locator) {
 502         if (locator.startsWith("/")) {
 503             return getWebDriver().findElement( By.xpath( locator ) );
 504         } else {
 505             return getWebDriver().findElement( By.id(locator) );
 506         }
 507     }
 508
 509
 510     public void submit()
 511     {
 512         clickLinkWithXPath( "//input[@type='submit']" );
 513     }
 514
 515     public void assertButtonWithValuePresent( String text )
 516     {
 517         Assert.assertTrue( "'" + text + "' button isn't present", isButtonWithValuePresent( text ) );
 518     }
 519
 520     public void assertButtonWithIdPresent( String id )
 521     {
 522         Assert.assertTrue( "'Button with id =" + id + "' isn't present", isButtonWithIdPresent( id ) );
 523     }
 524
 525     public void assertButtonWithValueNotPresent( String text )
 526     {
 527         Assert.assertFalse( "'" + text + "' button is present", isButtonWithValuePresent( text ) );
 528     }
 529
 530     public boolean isButtonWithValuePresent( String text )
 531     {
 532         return isElementPresent( "//button[@value='" + text + "']" ) || isElementPresent(
 533             "//input[@value='" + text + "']" );
 534     }
 535
 536     public boolean isButtonWithIdPresent( String text )
 537     {
 538         return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 539     }
 540
 541     public void clickButtonWithName( String text, boolean wait )
 542     {
 543         clickLinkWithXPath( "//input[@name='" + text + "']", wait );
 544     }
 545
 546     public void clickButtonWithValue( String text )
 547     {
 548         clickButtonWithValue( text, false );
 549     }
 550
 551     public void clickButtonWithValue( String text, boolean wait )
 552     {
 553         assertButtonWithValuePresent( text );
 554
 555         if ( isElementPresent( "//button[@value='" + text + "']" ) )
 556         {
 557             clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 558         }
 559         else
 560         {
 561             clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 562         }
 563     }
 564
 565     public void clickSubmitWithLocator( String locator )
 566     {
 567         clickLinkWithLocator( locator );
 568     }
 569
 570     public void clickSubmitWithLocator( String locator, boolean wait )
 571     {
 572         clickLinkWithLocator( locator, wait );
 573     }
 574
 575     public void clickImgWithAlt( String alt )
 576     {
 577         clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 578     }
 579
 580     public void clickLinkWithText( String text )
 581     {
 582         clickLinkWithText( text, false );
 583     }
 584
 585     public void clickLinkWithText( String text, boolean wait )
 586     {
 587         clickLinkWithLocator( "//*[text()='" + text +"']//ancestor::a", wait );
 588     }
 589
 590     public void clickLinkWithXPath( String xpath )
 591     {
 592         clickLinkWithXPath( xpath, false );
 593     }
 594
 595     public void clickLinkWithXPath( String xpath, boolean wait )
 596     {
 597         clickLinkWithLocator( xpath, wait );
 598     }
 599
 600     public void clickLinkWithLocator( String locator )
 601     {
 602         clickLinkWithLocator( locator, false );
 603     }
 604
 605     public void clickLinkWithLocator( String locator, boolean wait )
 606     {
 607         assertElementPresent( locator );
 608         findElement(locator).click();
 609         if ( wait )
 610         {
 611             waitPage();
 612         }
 613     }
 614
 615     public void clickButtonWithLocator( String locator )
 616     {
 617         clickButtonWithLocator( locator, false );
 618     }
 619
 620     public void clickButtonWithLocator( String locator, boolean wait )
 621     {
 622         assertElementPresent( locator );
 623         findElement(locator ).click();
 624         if ( wait )
 625         {
 626             waitPage();
 627         }
 628     }
 629
 630     public <V> V tryClick(By clickableLocator, Function<? super WebDriver, V> conditions, String message, int attempts, int maxWaitTimeInS) {
 631
 632         getWebDriver().manage().window().maximize();
 633         int count = attempts;
 634         WebDriverWait wait = new WebDriverWait( getWebDriver(), maxWaitTimeInS );
 635         V result = null;
 636         Exception ex = null;
 637         WebElement el = null;
 638         while(count>0)
 639         {
 640             try
 641             {
 642                 el = wait.until(ExpectedConditions.elementToBeClickable( clickableLocator ));
 643                 Actions actions = new Actions(getWebDriver());
 644                 actions.moveToElement(el).click().perform();
 645                 result = wait.until( conditions  );
 646                 return result;
 647             } catch (Exception e) {
 648                 logger.info("Error: {}, {}, {}",count,e.getClass().getName(), e.getMessage());
 649                 if (el!=null) {
 650                     Point elLoc = el.getLocation();
 651                     logger.info("Location: x={} y={}", elLoc.getX(), elLoc.getY());
 652                 }
 653                 ex = e;
 654                 count--;
 655             }
 656             try
 657             {
 658                 Thread.currentThread().sleep(500);
 659             }
 660             catch ( InterruptedException e )
 661             {
 662                 // Ignore
 663             }
 664         }
 665         if (ex!=null) {
 666             Assert.fail( message);
 667         }
 668         return result;
 669     }
 670
 671     /**
 672      * Executes click() on the WebElement <code>el</code> and waits for the conditions.
 673      * If the condition is not fulfilled in <code>maxWaitTimeInS</code>, the click is executed again
 674      * and waits again for the condition.
 675      * After the number of attempts as given by the parameter an assertion error will be thrown, with
 676      * the given <code>message</code>.
 677      *
 678      * If the click was successful the element is returned that was created by the condition.
 679      *
 680      * @param el The element where the click is executed
 681      * @param conditions The conditions to wait for after the click
 682      * @param message The assertion messages
 683      * @param attempts Maximum number of click attempts
 684      * @param maxWaitTimeInS The time in seconds to wait that the condition is fulfilled.
 685      * @param <V> The return type
 686      * @return
 687      */
 688     public <V> V tryClick( WebElement el, Function<? super WebDriver, V> conditions, String message, int attempts, int maxWaitTimeInS)
 689     {
 690         int count = attempts;
 691         WebDriverWait wait = new WebDriverWait( getWebDriver(), maxWaitTimeInS );
 692         V result = null;
 693         Exception ex = null;
 694         while(count>0)
 695         {
 696             if (count<attempts) {
 697                 try
 698                 {
 699                     result = conditions.apply( getWebDriver() );
 700                     return result;
 701                 } catch (Exception e) {
 702                     // Ignore
 703                 }
 704             }
 705             el.click();
 706             try
 707             {
 708                 result = wait.until( conditions  );
 709                 return result;
 710             } catch (Exception e) {
 711                 logger.info("Error: {}, {}",count, e.getMessage());
 712                 ex = e;
 713                 count--;
 714             }
 715             try
 716             {
 717                 Thread.currentThread().sleep(500);
 718             }
 719             catch ( InterruptedException e )
 720             {
 721                 // Ignore
 722             }
 723         }
 724         if (ex!=null) {
 725             Assert.fail( message);
 726         }
 727         return result;
 728     }
 729
 730     public <V> V tryClick(WebElement el, Function<? super WebDriver, V> conditions, String message, int attempts )
 731     {
 732         return tryClick( el, conditions, message, attempts, 10 );
 733     }
 734
 735     public <V> V tryClick(WebElement el, Function<? super WebDriver, V> conditions, String message)
 736     {
 737         return tryClick( el, conditions, message, 3);
 738     }
 739
 740
 741     public void setFieldValues( Map<String, String> fieldMap )
 742     {
 743         Map.Entry<String, String> entry;
 744
 745         for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 746         {
 747             entry = entries.next();
 748
 749             setFieldValue( entry.getKey(), entry.getValue() );
 750         }
 751     }
 752
 753     public void setFieldValue( String fieldName, String value )
 754     {
 755         findElement(fieldName ).sendKeys( value );
 756     }
 757
 758     public void checkField( String locator )
 759     {
 760         WebElement element = findElement(locator );
 761         if (!element.isSelected()) {
 762             element.click();
 763         }
 764     }
 765
 766     public void uncheckField( String locator )
 767     {
 768         WebElement element = findElement(locator );
 769         if (element.isSelected()) {
 770             element.click();
 771         }
 772     }
 773
 774     public boolean isChecked( String locator )
 775     {
 776         return findElement(locator ).isSelected();
 777     }
 778
 779     public void assertIsChecked( String locator )
 780     {
 781
 782         Assert.assertTrue( isChecked( locator ));
 783     }
 784
 785     public void assertIsNotChecked( String locator )
 786     {
 787
 788         Assert.assertFalse( isChecked( locator ) );
 789     }
 790
 791
 792
 793     public String captureScreenShotOnFailure( Throwable failure, String methodName, String className )
 794     {
 795         SimpleDateFormat sdf = new SimpleDateFormat( "yyyy.MM.dd-HH_mm_ss" );
 796         String time = sdf.format( new Date() );
 797         File targetPath = new File( "target", "screenshots" );
 798
 799         int lineNumber = 0;
 800
 801         for ( StackTraceElement stackTrace : failure.getStackTrace() )
 802         {
 803             if ( stackTrace.getClassName().equals( this.getClass().getName() ) )
 804             {
 805                 lineNumber = stackTrace.getLineNumber();
 806                 break;
 807             }
 808         }
 809
 810         targetPath.mkdirs();
 811         if (getWebDriver()!=null)
 812         {
 813             String fileBaseName = methodName + "_" + className + ".java_" + lineNumber + "-" + time;
 814             File fileName = new File( targetPath, fileBaseName + ".png" );
 815             Path screenshot = WebdriverUtility.takeScreenShot( fileName.getName(), getWebDriver());
 816             return fileName.getAbsolutePath();
 817         } else {
 818             return "";
 819         }
 820     }
 821
 822 }