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