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