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