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 com.thoughtworks.selenium.DefaultSelenium;
  23 import com.thoughtworks.selenium.Selenium;
  24 import org.apache.archiva.web.test.tools.AfterSeleniumFailure;
  25 import org.apache.archiva.web.test.tools.ScreenshotCaptureRule;
  26 import org.junit.Assert;
  27 import org.junit.Rule;
  28
  29 import java.io.File;
  30 import java.text.SimpleDateFormat;
  31 import java.util.Arrays;
  32 import java.util.Date;
  33 import java.util.Iterator;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Map.Entry;
  37 import java.util.Properties;
  38
  39 /**
  40  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  41  * @version $Id: AbstractSeleniumTestCase.java 761154 2009-04-02 03:31:19Z wsmoak $
  42  */
  43
  44 public abstract class AbstractSeleniumTest
  45 {
  46
  47     @Rule
  48     public ScreenshotCaptureRule screenshotCaptureRule = new ScreenshotCaptureRule();
  49
  50     public String browser = System.getProperty( "browser" );
  51
  52     public String baseUrl = System.getProperty( "baseUrl" );
  53
  54     public int maxWaitTimeInMs = Integer.getInteger( "maxWaitTimeInMs" );
  55
  56     public String seleniumHost = System.getProperty( "seleniumHost", "localhost" );
  57
  58     public int seleniumPort = Integer.getInteger( "seleniumPort", 4444 );
  59
  60     private Selenium selenium = null;
  61
  62     public Properties p;
  63
  64     public void open()
  65         throws Exception
  66     {
  67         p = new Properties();
  68         p.load( this.getClass().getClassLoader().getResourceAsStream( "test.properties" ) );
  69         open( baseUrl, browser, seleniumHost, seleniumPort, maxWaitTimeInMs );
  70         screenshotCaptureRule.selenium = selenium;
  71         assertAdminCreated();
  72     }
  73
  74     /**
  75      * Close selenium session.
  76      */
  77     public void close()
  78     {
  79         if ( getSelenium() != null )
  80         {
  81             getSelenium().stop();
  82         }
  83     }
  84
  85     /**
  86      * Initialize selenium
  87      */
  88     public void open( String baseUrl, String browser, String seleniumHost, int seleniumPort, int maxWaitTimeInMs )
  89         throws Exception
  90     {
  91         try
  92         {
  93             if ( getSelenium() == null )
  94             {
  95                 selenium = new DefaultSelenium( seleniumHost, seleniumPort, browser, baseUrl );
  96                 selenium.start();
  97                 selenium.setTimeout( Integer.toString( maxWaitTimeInMs ) );
  98             }
  99         }
 100         catch ( Exception e )
 101         {
 102             // yes
 103             System.out.print( e.getMessage() );
 104             e.printStackTrace();
 105         }
 106     }
 107
 108     public void assertAdminCreated()
 109         throws Exception
 110     {
 111         initializeArchiva( baseUrl, browser, maxWaitTimeInMs, seleniumHost, seleniumPort );
 112     }
 113
 114     public void initializeArchiva( String baseUrl, String browser, int maxWaitTimeInMs, String seleniumHost,
 115                                    int seleniumPort )
 116         throws Exception
 117     {
 118
 119         open( baseUrl, browser, seleniumHost, seleniumPort, maxWaitTimeInMs );
 120
 121         getSelenium().open( baseUrl );
 122
 123         waitPage();
 124
 125         // if not admin user created create one
 126         if ( isElementVisible( "create-admin-link" ) )
 127         {
 128             Assert.assertFalse( getSelenium().isVisible( "login-link-a" ) );
 129             Assert.assertFalse( getSelenium().isVisible( "register-link-a" ) );
 130             clickLinkWithLocator( "create-admin-link-a", false );
 131             assertCreateAdmin();
 132             String fullname = getProperty( "ADMIN_FULLNAME" );
 133             String username = getAdminUsername();
 134             String mail = getProperty( "ADMIN_EMAIL" );
 135             String password = getProperty( "ADMIN_PASSWORD" );
 136             submitAdminData( fullname, mail, password );
 137             assertUserLoggedIn( username );
 138             clickLinkWithLocator( "logout-link-a" );
 139         }
 140         else
 141         {
 142             Assert.assertTrue( getSelenium().isVisible( "login-link-a" ) );
 143             Assert.assertTrue( getSelenium().isVisible( "register-link-a" ) );
 144             login( getAdminUsername(), getAdminPassword() );
 145         }
 146
 147     }
 148
 149     public Selenium getSelenium()
 150     {
 151         return selenium;
 152     }
 153
 154     protected String getProperty( String key )
 155     {
 156         return p.getProperty( key );
 157     }
 158
 159     public String getAdminUsername()
 160     {
 161         String adminUsername = getProperty( "ADMIN_USERNAME" );
 162         return adminUsername;
 163     }
 164
 165     public String getAdminPassword()
 166     {
 167         String adminPassword = getProperty( "ADMIN_PASSWORD" );
 168         return adminPassword;
 169     }
 170
 171     public void submitAdminData( String fullname, String email, String password )
 172     {
 173         setFieldValue( "fullname", fullname );
 174         setFieldValue( "email", email );
 175         setFieldValue( "password", password );
 176         setFieldValue( "confirmPassword", password );
 177         clickButtonWithLocator( "user-create-form-register-button" );
 178     }
 179
 180     public void login( String username, String password )
 181     {
 182         login( username, password, true, "Login Page" );
 183     }
 184
 185     public void login( String username, String password, boolean valid, String assertReturnPage )
 186     {
 187         if ( isElementVisible( "login-link-a" ) )//isElementPresent( "loginLink" ) )
 188         {
 189             goToLoginPage();
 190
 191             submitLoginPage( username, password, false, valid, assertReturnPage );
 192         }
 193         if ( valid )
 194         {
 195             assertUserLoggedIn( username );
 196         }
 197     }
 198
 199     // Go to Login Page
 200     public void goToLoginPage()
 201     {
 202         getSelenium().open( baseUrl );
 203         waitPage();
 204         // are we already logged in ?
 205         if ( isElementVisible( "logout-link" ) ) //isElementPresent( "logoutLink" ) )
 206         {
 207             // so logout
 208             clickLinkWithLocator( "logout-link-a", false );
 209             clickLinkWithLocator( "login-link-a" );
 210         }
 211         else if ( isElementVisible( "login-link-a" ) )
 212         {
 213             clickLinkWithLocator( "login-link-a" );
 214         }
 215         assertLoginModal();
 216     }
 217
 218
 219     public void assertLoginModal()
 220     {
 221         assertElementPresent( "user-login-form" );
 222         Assert.assertTrue( isElementVisible( "register-link" ) );
 223         assertElementPresent( "user-login-form-username" );
 224         assertElementPresent( "user-login-form-password" );
 225         assertButtonWithIdPresent( "modal-login-ok" );
 226     }
 227
 228
 229     public void submitLoginPage( String username, String password )
 230     {
 231         submitLoginPage( username, password, false, true, "Login Page" );
 232     }
 233
 234     public void submitLoginPage( String username, String password, boolean validUsernamePassword )
 235     {
 236         submitLoginPage( username, password, false, validUsernamePassword, "Login Page" );
 237     }
 238
 239     public void submitLoginPage( String username, String password, boolean rememberMe, boolean validUsernamePassword,
 240                                  String assertReturnPage )
 241     {
 242         clickLinkWithLocator( "login-link-a", false );
 243         setFieldValue( "user-login-form-username", username );
 244         setFieldValue( "user-login-form-password", password );
 245         /*
 246         if ( rememberMe )
 247         {
 248             checkField( "rememberMe" );
 249         }*/
 250
 251         clickButtonWithLocator( "modal-login-ok" );
 252         if ( validUsernamePassword )
 253         {
 254             assertUserLoggedIn( username );
 255         }
 256         /*
 257         else
 258         {
 259             if ( "Login Page".equals( assertReturnPage ) )
 260             {
 261                 assertLoginPage();
 262             }
 263             else
 264             {
 265                 assertPage( assertReturnPage );
 266             }
 267         }*/
 268     }
 269
 270     // *******************************************************
 271     // Auxiliar methods. This method help us and simplify test.
 272     // *******************************************************
 273
 274     protected void assertUserLoggedIn( String username )
 275     {
 276         Assert.assertFalse( isElementVisible( "login-link" ) );
 277         Assert.assertTrue( isElementVisible( "logout-link" ) );
 278         Assert.assertFalse( isElementVisible( "register-link" ) );
 279         Assert.assertFalse( isElementVisible( "create-admin-link" ) );
 280     }
 281
 282     public void assertCreateAdmin()
 283     {
 284         assertElementPresent( "user-create" );
 285         assertFieldValue( "admin", "username" );
 286         assertElementPresent( "fullname" );
 287         assertElementPresent( "password" );
 288         assertElementPresent( "confirmPassword" );
 289         assertElementPresent( "email" );
 290     }
 291
 292     public void assertFieldValue( String fieldValue, String fieldName )
 293     {
 294         assertElementPresent( fieldName );
 295         Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
 296     }
 297
 298     public void assertPage( String title )
 299     {
 300         Assert.assertEquals( getTitle(), title );
 301     }
 302
 303     public String getTitle()
 304     {
 305         // Collapse spaces
 306         return getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
 307     }
 308
 309     public String getHtmlContent()
 310     {
 311         return getSelenium().getHtmlSource();
 312     }
 313
 314     public String getText( String locator )
 315     {
 316         return getSelenium().getText( locator );
 317     }
 318
 319     public void assertTextPresent( String text )
 320     {
 321         Assert.assertTrue( "'" + text + "' isn't present.", getSelenium().isTextPresent( text ) );
 322     }
 323
 324     /**
 325      * one of text args must be in the page so use en and fr text (olamy use en locale :-) )
 326      *
 327      * @param texts
 328      */
 329     public void assertTextPresent( String... texts )
 330     {
 331         boolean present = false;
 332         StringBuilder sb = new StringBuilder();
 333         for ( String text : texts )
 334         {
 335             present = present || getSelenium().isTextPresent( text );
 336             sb.append( " " + text + " " );
 337         }
 338         Assert.assertTrue( "'one of the following test " + sb.toString() + "' isn't present.", present );
 339     }
 340
 341     public void assertTextNotPresent( String text )
 342     {
 343         Assert.assertFalse( "'" + text + "' is present.", getSelenium().isTextPresent( text ) );
 344     }
 345
 346     public void assertElementPresent( String elementLocator )
 347     {
 348         Assert.assertTrue( "'" + elementLocator + "' isn't present.", isElementPresent( elementLocator ) );
 349     }
 350
 351     public void assertElementNotPresent( String elementLocator )
 352     {
 353         Assert.assertFalse( "'" + elementLocator + "' is present.", isElementPresent( elementLocator ) );
 354     }
 355
 356     public void assertLinkPresent( String text )
 357     {
 358         Assert.assertTrue( "The link '" + text + "' isn't present.", isElementPresent( "link=" + text ) );
 359     }
 360
 361     public void assertLinkNotPresent( String text )
 362     {
 363         Assert.assertFalse( "The link('" + text + "' is present.", isElementPresent( "link=" + text ) );
 364     }
 365
 366     public void assertLinkNotVisible( String text )
 367     {
 368         Assert.assertFalse( "The link('" + text + "' is visible.", isElementVisible( "link=" + text ) );
 369     }
 370
 371     public void assertLinkVisible( String text )
 372     {
 373         Assert.assertTrue( "The link('" + text + "' is not visible.", isElementVisible( "link=" + text ) );
 374     }
 375
 376     public void assertImgWithAlt( String alt )
 377     {
 378         assertElementPresent( "/¯img[@alt='" + alt + "']" );
 379     }
 380
 381     public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 382     {
 383         String locator = "//tr[" + row + "]/td[" + column + "]/";
 384         locator += isALink ? "a/" : "";
 385         locator += "img[@alt='" + alt + "']";
 386
 387         assertElementPresent( locator );
 388     }
 389
 390     public void assertImgWithAltNotPresent( String alt )
 391     {
 392         assertElementNotPresent( "/¯img[@alt='" + alt + "']" );
 393     }
 394
 395     public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 396     {
 397         Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 398     }
 399
 400     public boolean isTextPresent( String text )
 401     {
 402         return getSelenium().isTextPresent( text );
 403     }
 404
 405     public boolean isLinkPresent( String text )
 406     {
 407         return isElementPresent( "link=" + text );
 408     }
 409
 410     public boolean isElementPresent( String locator )
 411     {
 412         return getSelenium().isElementPresent( locator );
 413     }
 414
 415     public boolean isElementVisible( String locator )
 416     {
 417         return getSelenium().isVisible( locator );
 418     }
 419
 420
 421     public void waitPage()
 422     {
 423         // TODO define a smaller maxWaitTimeJsInMs for wait javascript response for browser side validation
 424         //getSelenium().w .wait( Long.parseLong( maxWaitTimeInMs ) );
 425         //getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 426         // http://jira.openqa.org/browse/SRC-302
 427         // those hack looks to break some tests :-(
 428         // getSelenium().waitForCondition( "selenium.isElementPresent('document.body');", maxWaitTimeInMs );
 429         //getSelenium().waitForCondition( "selenium.isElementPresent('footer');", maxWaitTimeInMs );
 430         //getSelenium().waitForCondition( "selenium.browserbot.getCurrentWindow().document.getElementById('footer')",
 431         //                                maxWaitTimeInMs );
 432         // so the only hack is to not use a too small wait time
 433
 434         try
 435         {
 436             Thread.sleep( maxWaitTimeInMs );
 437         }
 438         catch ( InterruptedException e )
 439         {
 440             throw new RuntimeException( "issue on Thread.sleep : " + e.getMessage(), e );
 441         }
 442     }
 443
 444     public String getFieldValue( String fieldName )
 445     {
 446         return getSelenium().getValue( fieldName );
 447     }
 448
 449     public String getCellValueFromTable( String tableElement, int row, int column )
 450     {
 451         return getSelenium().getTable( tableElement + "." + row + "." + column );
 452     }
 453
 454     public void selectValue( String locator, String value )
 455     {
 456         getSelenium().select( locator, "label=" + value );
 457     }
 458
 459
 460     public void assertOptionPresent( String selectField, String[] options )
 461     {
 462         assertElementPresent( selectField );
 463         String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 464         List<String> expected = Arrays.asList( options );
 465         List<String> present = Arrays.asList( optionsPresent );
 466         Assert.assertTrue( "Options expected are not included in present options", present.containsAll( expected ) );
 467     }
 468
 469     public void assertSelectedValue( String value, String fieldName )
 470     {
 471         assertElementPresent( fieldName );
 472         String optionsPresent = getSelenium().getSelectedLabel( value );
 473         Assert.assertEquals( optionsPresent, value );
 474     }
 475
 476     public void submit()
 477     {
 478         clickLinkWithXPath( "//input[@type='submit']" );
 479     }
 480
 481     public void assertButtonWithValuePresent( String text )
 482     {
 483         Assert.assertTrue( "'" + text + "' button isn't present", isButtonWithValuePresent( text ) );
 484     }
 485
 486     public void assertButtonWithIdPresent( String id )
 487     {
 488         Assert.assertTrue( "'Button with id =" + id + "' isn't present", isButtonWithIdPresent( id ) );
 489     }
 490
 491     public void assertButtonWithValueNotPresent( String text )
 492     {
 493         Assert.assertFalse( "'" + text + "' button is present", isButtonWithValuePresent( text ) );
 494     }
 495
 496     public boolean isButtonWithValuePresent( String text )
 497     {
 498         return isElementPresent( "//button[@value='" + text + "']" ) || isElementPresent(
 499             "//input[@value='" + text + "']" );
 500     }
 501
 502     public boolean isButtonWithIdPresent( String text )
 503     {
 504         return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 505     }
 506
 507     public void clickButtonWithName( String text, boolean wait )
 508     {
 509         clickLinkWithXPath( "//input[@name='" + text + "']", wait );
 510     }
 511
 512     public void clickButtonWithValue( String text )
 513     {
 514         clickButtonWithValue( text, true );
 515     }
 516
 517     public void clickButtonWithValue( String text, boolean wait )
 518     {
 519         assertButtonWithValuePresent( text );
 520
 521         if ( isElementPresent( "//button[@value='" + text + "']" ) )
 522         {
 523             clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 524         }
 525         else
 526         {
 527             clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 528         }
 529     }
 530
 531     public void clickSubmitWithLocator( String locator )
 532     {
 533         clickLinkWithLocator( locator );
 534     }
 535
 536     public void clickSubmitWithLocator( String locator, boolean wait )
 537     {
 538         clickLinkWithLocator( locator, wait );
 539     }
 540
 541     public void clickImgWithAlt( String alt )
 542     {
 543         clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 544     }
 545
 546     public void clickLinkWithText( String text )
 547     {
 548         clickLinkWithText( text, true );
 549     }
 550
 551     public void clickLinkWithText( String text, boolean wait )
 552     {
 553         clickLinkWithLocator( "link=" + text, wait );
 554     }
 555
 556     public void clickLinkWithXPath( String xpath )
 557     {
 558         clickLinkWithXPath( xpath, true );
 559     }
 560
 561     public void clickLinkWithXPath( String xpath, boolean wait )
 562     {
 563         clickLinkWithLocator( "xpath=" + xpath, wait );
 564     }
 565
 566     public void clickLinkWithLocator( String locator )
 567     {
 568         clickLinkWithLocator( locator, true );
 569     }
 570
 571     public void clickLinkWithLocator( String locator, boolean wait )
 572     {
 573         assertElementPresent( locator );
 574         getSelenium().click( locator );
 575         if ( wait )
 576         {
 577             waitPage();
 578         }
 579     }
 580
 581     public void clickButtonWithLocator( String locator )
 582     {
 583         clickButtonWithLocator( locator, true );
 584     }
 585
 586     public void clickButtonWithLocator( String locator, boolean wait )
 587     {
 588         assertElementPresent( locator );
 589         getSelenium().click( locator );
 590         if ( wait )
 591         {
 592             waitPage();
 593         }
 594     }
 595
 596     public void setFieldValues( Map<String, String> fieldMap )
 597     {
 598         Map.Entry<String, String> entry;
 599
 600         for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 601         {
 602             entry = entries.next();
 603
 604             getSelenium().type( entry.getKey(), entry.getValue() );
 605         }
 606     }
 607
 608     public void setFieldValue( String fieldName, String value )
 609     {
 610         getSelenium().type( fieldName, value );
 611     }
 612
 613     public void checkField( String locator )
 614     {
 615         getSelenium().check( locator );
 616     }
 617
 618     public void uncheckField( String locator )
 619     {
 620         getSelenium().uncheck( locator );
 621     }
 622
 623     public boolean isChecked( String locator )
 624     {
 625         return getSelenium().isChecked( locator );
 626     }
 627
 628     public void assertIsChecked( String locator )
 629     {
 630         Assert.assertTrue( getSelenium().isChecked( locator ) );
 631     }
 632
 633     public void assertIsNotChecked( String locator )
 634     {
 635         Assert.assertFalse( getSelenium().isChecked( locator ) );
 636     }
 637
 638     public void assertXpathCount( String locator, int expectedCount )
 639     {
 640         int count = getSelenium().getXpathCount( locator ).intValue();
 641         Assert.assertEquals( count, expectedCount );
 642     }
 643
 644     public void assertElementValue( String locator, String expectedValue )
 645     {
 646         Assert.assertEquals( getSelenium().getValue( locator ), expectedValue );
 647     }
 648
 649     @AfterSeleniumFailure
 650     public void captureScreenShotOnFailure( Throwable failure, String methodName, String className )
 651     {
 652         SimpleDateFormat sdf = new SimpleDateFormat( "yyyy.MM.dd-HH_mm_ss" );
 653         String time = sdf.format( new Date() );
 654         File targetPath = new File( "target", "screenshots" );
 655
 656         int lineNumber = 0;
 657
 658         for ( StackTraceElement stackTrace : failure.getStackTrace() )
 659         {
 660             if ( stackTrace.getClassName().equals( this.getClass().getName() ) )
 661             {
 662                 lineNumber = stackTrace.getLineNumber();
 663                 break;
 664             }
 665         }
 666
 667         targetPath.mkdirs();
 668         Selenium selenium = getSelenium();
 669         String fileBaseName = methodName + "_" + className + ".java_" + lineNumber + "-" + time;
 670
 671         selenium.windowMaximize();
 672
 673         File fileName = new File( targetPath, fileBaseName + ".png" );
 674         selenium.captureEntirePageScreenshot( fileName.getAbsolutePath(), "background=#FFFFFF" );
 675
 676     }
 677
 678 }