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