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