source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.web.test.parent;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.thoughtworks.selenium.DefaultSelenium;
  23 import com.thoughtworks.selenium.Selenium;
  24 import org.apache.archiva.web.test.tools.AfterSeleniumFailure;
  25 import org.apache.commons.io.IOUtils;
  26 import org.junit.Assert;
  27
  28 import java.io.File;
  29 import java.io.IOException;
  30 import java.io.InputStream;
  31 import java.text.SimpleDateFormat;
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.Date;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Map.Entry;
  39 import java.util.Properties;
  40 import java.util.regex.Pattern;
  41
  42 /**
  43  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  44  * @version $Id: AbstractSeleniumTestCase.java 761154 2009-04-02 03:31:19Z wsmoak $
  45  */
  46
  47 public abstract class AbstractSeleniumTest
  48 {
  49
  50     public static String baseUrl;
  51
  52     public static String maxWaitTimeInMs;
  53
  54     private static ThreadLocal<Selenium> selenium = new ThreadLocal<Selenium>();
  55
  56     public static Properties p;
  57
  58     private final static String PROPERTIES_SEPARATOR = "=";
  59
  60     public void open()
  61         throws Exception
  62     {
  63         p = new Properties();
  64         p.load( this.getClass().getClassLoader().getResourceAsStream( "test.properties" ) );
  65     }
  66
  67     /**
  68      * Initialize selenium
  69      */
  70     public void open( String baseUrl, String browser, String seleniumHost, int seleniumPort, String maxWaitTimeInMs )
  71         throws Exception
  72     {
  73         try
  74         {
  75             AbstractSeleniumTest.baseUrl = baseUrl;
  76             AbstractSeleniumTest.maxWaitTimeInMs = maxWaitTimeInMs;
  77
  78             if ( getSelenium() == null )
  79             {
  80                 DefaultSelenium s = new DefaultSelenium( seleniumHost, seleniumPort, browser, baseUrl );
  81
  82                 s.start();
  83                 s.setTimeout( maxWaitTimeInMs );
  84                 selenium.set( s );
  85             }
  86         }
  87         catch ( Exception e )
  88         {
  89             // yes
  90             System.out.print( e.getMessage() );
  91             e.printStackTrace();
  92         }
  93     }
  94
  95     public static Selenium getSelenium()
  96     {
  97         return selenium == null ? null : selenium.get();
  98     }
  99
 100     protected String getProperty( String key )
 101     {
 102         return p.getProperty( key );
 103     }
 104
 105     protected String getEscapeProperty( String key )
 106     {
 107         InputStream input = this.getClass().getClassLoader().getResourceAsStream( "test.properties" );
 108         String value = null;
 109         List<String> lines;
 110         try
 111         {
 112             lines = IOUtils.readLines( input );
 113         }
 114         catch ( IOException e )
 115         {
 116             lines = new ArrayList<String>();
 117         }
 118         for ( String l : lines )
 119         {
 120             if ( l != null && l.startsWith( key ) )
 121             {
 122                 int indexSeparator = l.indexOf( PROPERTIES_SEPARATOR );
 123                 value = l.substring( indexSeparator + 1 ).trim();
 124                 break;
 125             }
 126         }
 127         return value;
 128     }
 129
 130     /**
 131      * Close selenium session.
 132      */
 133     public void close()
 134         throws Exception
 135     {
 136         if ( getSelenium() != null )
 137         {
 138             getSelenium().stop();
 139             selenium.set( null );
 140         }
 141     }
 142
 143     // *******************************************************
 144     // Auxiliar methods. This method help us and simplify test.
 145     // *******************************************************
 146
 147     public void assertFieldValue( String fieldValue, String fieldName )
 148     {
 149         assertElementPresent( fieldName );
 150         Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
 151     }
 152
 153     public void assertPage( String title )
 154     {
 155         Assert.assertEquals( getTitle(), title );
 156     }
 157
 158     public String getTitle()
 159     {
 160         // Collapse spaces
 161         return getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
 162     }
 163
 164     public String getHtmlContent()
 165     {
 166         return getSelenium().getHtmlSource();
 167     }
 168
 169     public String getText( String locator )
 170     {
 171         return getSelenium().getText( locator );
 172     }
 173
 174     public void assertTextPresent( String text )
 175     {
 176         Assert.assertTrue( "'" + text + "' isn't present.", getSelenium().isTextPresent( text ) );
 177     }
 178
 179     /**
 180      * one of text args must be in the page so use en and fr text (olamy use en locale :-) )
 181      *
 182      * @param texts
 183      */
 184     public void assertTextPresent( String... texts )
 185     {
 186         boolean present = false;
 187         StringBuilder sb = new StringBuilder();
 188         for ( String text : texts )
 189         {
 190             present = present || getSelenium().isTextPresent( text );
 191             sb.append( " " + text + " " );
 192         }
 193         Assert.assertTrue( "'one of the following test " + sb.toString() + "' isn't present.", present );
 194     }
 195
 196     public void assertTextNotPresent( String text )
 197     {
 198         Assert.assertFalse( "'" + text + "' is present.", getSelenium().isTextPresent( text ) );
 199     }
 200
 201     public void assertElementPresent( String elementLocator )
 202     {
 203         Assert.assertTrue( "'" + elementLocator + "' isn't present.", isElementPresent( elementLocator ) );
 204     }
 205
 206     public void assertElementNotPresent( String elementLocator )
 207     {
 208         Assert.assertFalse( "'" + elementLocator + "' is present.", isElementPresent( elementLocator ) );
 209     }
 210
 211     public void assertLinkPresent( String text )
 212     {
 213         Assert.assertTrue( "The link '" + text + "' isn't present.", isElementPresent( "link=" + text ) );
 214     }
 215
 216     public void assertLinkNotPresent( String text )
 217     {
 218         Assert.assertFalse( "The link('" + text + "' is present.", isElementPresent( "link=" + text ) );
 219     }
 220
 221     public void assertLinkNotVisible( String text )
 222     {
 223         Assert.assertFalse( "The link('" + text + "' is visible.", isElementVisible( "link=" + text ) );
 224     }
 225
 226     public void assertLinkVisible( String text )
 227     {
 228         Assert.assertTrue( "The link('" + text + "' is not visible.", isElementVisible( "link=" + text ) );
 229     }
 230
 231     public void assertImgWithAlt( String alt )
 232     {
 233         assertElementPresent( "/¯img[@alt='" + alt + "']" );
 234     }
 235
 236     public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 237     {
 238         String locator = "//tr[" + row + "]/td[" + column + "]/";
 239         locator += isALink ? "a/" : "";
 240         locator += "img[@alt='" + alt + "']";
 241
 242         assertElementPresent( locator );
 243     }
 244
 245     public void assertImgWithAltNotPresent( String alt )
 246     {
 247         assertElementNotPresent( "/¯img[@alt='" + alt + "']" );
 248     }
 249
 250     public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 251     {
 252         Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 253     }
 254
 255     public boolean isTextPresent( String text )
 256     {
 257         return getSelenium().isTextPresent( text );
 258     }
 259
 260     public boolean isLinkPresent( String text )
 261     {
 262         return isElementPresent( "link=" + text );
 263     }
 264
 265     public boolean isElementPresent( String locator )
 266     {
 267         return getSelenium().isElementPresent( locator );
 268     }
 269
 270     public boolean isElementVisible( String locator )
 271     {
 272         return getSelenium().isVisible( locator );
 273     }
 274
 275
 276     public void waitPage()
 277     {
 278         // TODO define a smaller maxWaitTimeJsInMs for wait javascript response for browser side validation
 279         //getSelenium().w .wait( Long.parseLong( maxWaitTimeInMs ) );
 280         //getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 281         // http://jira.openqa.org/browse/SRC-302
 282         // those hack looks to break some tests :-(
 283         // getSelenium().waitForCondition( "selenium.isElementPresent('document.body');", maxWaitTimeInMs );
 284         //getSelenium().waitForCondition( "selenium.isElementPresent('footer');", maxWaitTimeInMs );
 285         //getSelenium().waitForCondition( "selenium.browserbot.getCurrentWindow().document.getElementById('footer')",
 286         //                                maxWaitTimeInMs );
 287         // so the only hack is to not use a too small wait time
 288
 289         try
 290         {
 291             Thread.sleep( Long.parseLong( maxWaitTimeInMs ) );
 292         }
 293         catch ( InterruptedException e )
 294         {
 295             throw new RuntimeException( "issue on Thread.sleep : " + e.getMessage(), e );
 296         }
 297     }
 298
 299     public String getFieldValue( String fieldName )
 300     {
 301         return getSelenium().getValue( fieldName );
 302     }
 303
 304     public String getCellValueFromTable( String tableElement, int row, int column )
 305     {
 306         return getSelenium().getTable( tableElement + "." + row + "." + column );
 307     }
 308
 309     public void selectValue( String locator, String value )
 310     {
 311         getSelenium().select( locator, "label=" + value );
 312     }
 313
 314
 315     public void assertOptionPresent( String selectField, String[] options )
 316     {
 317         assertElementPresent( selectField );
 318         String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 319         List<String> expected = Arrays.asList( options );
 320         List<String> present = Arrays.asList( optionsPresent );
 321         Assert.assertTrue( "Options expected are not included in present options", present.containsAll( expected ) );
 322     }
 323
 324     public void assertSelectedValue( String value, String fieldName )
 325     {
 326         assertElementPresent( fieldName );
 327         String optionsPresent = getSelenium().getSelectedLabel( value );
 328         Assert.assertEquals( optionsPresent, value );
 329     }
 330
 331     public void submit()
 332     {
 333         clickLinkWithXPath( "//input[@type='submit']" );
 334     }
 335
 336     public void assertButtonWithValuePresent( String text )
 337     {
 338         Assert.assertTrue( "'" + text + "' button isn't present", isButtonWithValuePresent( text ) );
 339     }
 340
 341     public void assertButtonWithIdPresent( String id )
 342     {
 343         Assert.assertTrue( "'Button with id =" + id + "' isn't present", isButtonWithIdPresent( id ) );
 344     }
 345
 346     public void assertButtonWithValueNotPresent( String text )
 347     {
 348         Assert.assertFalse( "'" + text + "' button is present", isButtonWithValuePresent( text ) );
 349     }
 350
 351     public boolean isButtonWithValuePresent( String text )
 352     {
 353         return isElementPresent( "//button[@value='" + text + "']" ) || isElementPresent(
 354             "//input[@value='" + text + "']" );
 355     }
 356
 357     public boolean isButtonWithIdPresent( String text )
 358     {
 359         return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 360     }
 361
 362     public void clickButtonWithName( String text, boolean wait )
 363     {
 364         clickLinkWithXPath( "//input[@name='" + text + "']", wait );
 365     }
 366
 367     public void clickButtonWithValue( String text )
 368     {
 369         clickButtonWithValue( text, true );
 370     }
 371
 372     public void clickButtonWithValue( String text, boolean wait )
 373     {
 374         assertButtonWithValuePresent( text );
 375
 376         if ( isElementPresent( "//button[@value='" + text + "']" ) )
 377         {
 378             clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 379         }
 380         else
 381         {
 382             clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 383         }
 384     }
 385
 386     public void clickSubmitWithLocator( String locator )
 387     {
 388         clickLinkWithLocator( locator );
 389     }
 390
 391     public void clickSubmitWithLocator( String locator, boolean wait )
 392     {
 393         clickLinkWithLocator( locator, wait );
 394     }
 395
 396     public void clickImgWithAlt( String alt )
 397     {
 398         clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 399     }
 400
 401     public void clickLinkWithText( String text )
 402     {
 403         clickLinkWithText( text, true );
 404     }
 405
 406     public void clickLinkWithText( String text, boolean wait )
 407     {
 408         clickLinkWithLocator( "link=" + text, wait );
 409     }
 410
 411     public void clickLinkWithXPath( String xpath )
 412     {
 413         clickLinkWithXPath( xpath, true );
 414     }
 415
 416     public void clickLinkWithXPath( String xpath, boolean wait )
 417     {
 418         clickLinkWithLocator( "xpath=" + xpath, wait );
 419     }
 420
 421     public void clickLinkWithLocator( String locator )
 422     {
 423         clickLinkWithLocator( locator, true );
 424     }
 425
 426     public void clickLinkWithLocator( String locator, boolean wait )
 427     {
 428         assertElementPresent( locator );
 429         getSelenium().click( locator );
 430         if ( wait )
 431         {
 432             waitPage();
 433         }
 434     }
 435
 436     public void clickButtonWithLocator( String locator )
 437     {
 438         clickButtonWithLocator( locator, true );
 439     }
 440
 441     public void clickButtonWithLocator( String locator, boolean wait )
 442     {
 443         assertElementPresent( locator );
 444         getSelenium().click( locator );
 445         if ( wait )
 446         {
 447             waitPage();
 448         }
 449     }
 450
 451     public void setFieldValues( Map<String, String> fieldMap )
 452     {
 453         Map.Entry<String, String> entry;
 454
 455         for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 456         {
 457             entry = entries.next();
 458
 459             getSelenium().type( entry.getKey(), entry.getValue() );
 460         }
 461     }
 462
 463     public void setFieldValue( String fieldName, String value )
 464     {
 465         getSelenium().type( fieldName, value );
 466     }
 467
 468     public void checkField( String locator )
 469     {
 470         getSelenium().check( locator );
 471     }
 472
 473     public void uncheckField( String locator )
 474     {
 475         getSelenium().uncheck( locator );
 476     }
 477
 478     public boolean isChecked( String locator )
 479     {
 480         return getSelenium().isChecked( locator );
 481     }
 482
 483     public void assertIsChecked( String locator )
 484     {
 485         Assert.assertTrue( getSelenium().isChecked( locator ) );
 486     }
 487
 488     public void assertIsNotChecked( String locator )
 489     {
 490         Assert.assertFalse( getSelenium().isChecked( locator ) );
 491     }
 492
 493     public void assertXpathCount( String locator, int expectedCount )
 494     {
 495         int count = getSelenium().getXpathCount( locator ).intValue();
 496         Assert.assertEquals( count, expectedCount );
 497     }
 498
 499     public void assertElementValue( String locator, String expectedValue )
 500     {
 501         Assert.assertEquals( getSelenium().getValue( locator ), expectedValue );
 502     }
 503
 504     @AfterSeleniumFailure
 505     public void captureScreenShotOnFailure( Throwable failure )
 506     {
 507         SimpleDateFormat sdf = new SimpleDateFormat( "yyyy.MM.dd-HH_mm_ss" );
 508         String time = sdf.format( new Date() );
 509         File targetPath = new File( "target", "screenshots" );
 510         StackTraceElement stackTrace[] = failure.getStackTrace();
 511         String cName = this.getClass().getName();
 512         int index = getStackTraceIndexOfCallingClass( cName, stackTrace );
 513         String methodName = stackTrace[index].getMethodName();
 514         int lNumber = stackTrace[index].getLineNumber();
 515         String lineNumber = Integer.toString( lNumber );
 516         String className = cName.substring( cName.lastIndexOf( '.' ) + 1 );
 517         targetPath.mkdirs();
 518         Selenium selenium = AbstractSeleniumTest.getSelenium();
 519         String fileBaseName = methodName + "_" + className + ".java_" + lineNumber + "-" + time;
 520
 521         selenium.windowMaximize();
 522
 523         File fileName = new File( targetPath, fileBaseName + ".png" );
 524         selenium.captureEntirePageScreenshot( fileName.getAbsolutePath(), "background=#FFFFFF" );
 525
 526     }
 527
 528     private int getStackTraceIndexOfCallingClass( String nameOfClass, StackTraceElement stackTrace[] )
 529     {
 530         boolean match = false;
 531         int i = 0;
 532         do
 533         {
 534             String className = stackTrace[i].getClassName();
 535             match = Pattern.matches( nameOfClass, className );
 536             i++;
 537         }
 538         while ( match == false );
 539         i--;
 540         return i;
 541     }
 542
 543 }