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