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.commons.io.IOUtils;
  25 import org.testng.Assert;
  26
  27 import java.io.IOException;
  28 import java.io.InputStream;
  29 import java.util.ArrayList;
  30 import java.util.Arrays;
  31 import java.util.Iterator;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Map.Entry;
  35 import java.util.Properties;
  36
  37 /**
  38  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  39  * @version $Id: AbstractSeleniumTestCase.java 761154 2009-04-02 03:31:19Z wsmoak $
  40  */
  41
  42 public abstract class AbstractSeleniumTest
  43 {
  44
  45     public static String baseUrl;
  46
  47     public static String maxWaitTimeInMs;
  48
  49     private static ThreadLocal<Selenium> selenium = new ThreadLocal<Selenium>();
  50
  51     public static Properties p;
  52
  53     private final static String PROPERTIES_SEPARATOR = "=";
  54
  55     public void open()
  56         throws Exception
  57     {
  58         p = new Properties();
  59         p.load( this.getClass().getClassLoader().getResourceAsStream( "testng.properties" ) );
  60     }
  61
  62     /**
  63      * Initialize selenium
  64      */
  65     public void open( String baseUrl, String browser, String seleniumHost, int seleniumPort, String maxWaitTimeInMs )
  66         throws Exception
  67     {
  68         try
  69         {
  70             AbstractSeleniumTest.baseUrl = baseUrl;
  71             AbstractSeleniumTest.maxWaitTimeInMs = maxWaitTimeInMs;
  72
  73             if ( getSelenium() == null )
  74             {
  75                 DefaultSelenium s = new DefaultSelenium( seleniumHost, seleniumPort, browser, baseUrl );
  76                 s.start();
  77                 s.setTimeout( maxWaitTimeInMs );
  78                 selenium.set( s );
  79             }
  80         }
  81         catch ( Exception e )
  82         {
  83             // yes
  84             System.out.print( e.getMessage() );
  85             e.printStackTrace();
  86         }
  87     }
  88
  89     public static Selenium getSelenium()
  90     {
  91         return selenium == null ? null : selenium.get();
  92     }
  93
  94     protected String getProperty( String key )
  95     {
  96         return p.getProperty( key );
  97     }
  98
  99     protected String getEscapeProperty( String key )
 100     {
 101         InputStream input = this.getClass().getClassLoader().getResourceAsStream( "testng.properties" );
 102         String value = null;
 103         List<String> lines;
 104         try
 105         {
 106             lines = IOUtils.readLines( input );
 107         }
 108         catch ( IOException e )
 109         {
 110             lines = new ArrayList<String>();
 111         }
 112         for ( String l : lines )
 113         {
 114             if ( l != null && l.startsWith( key ) )
 115             {
 116                 int indexSeparator = l.indexOf( PROPERTIES_SEPARATOR );
 117                 value = l.substring( indexSeparator + 1 ).trim();
 118                 break;
 119             }
 120         }
 121         return value;
 122     }
 123
 124     /**
 125      * Close selenium session. Called from AfterSuite method of sub-class
 126      */
 127     public void close()
 128         throws Exception
 129     {
 130         if ( getSelenium() != null )
 131         {
 132             getSelenium().stop();
 133             selenium.set( null );
 134         }
 135     }
 136
 137     // *******************************************************
 138     // Auxiliar methods. This method help us and simplify test.
 139     // *******************************************************
 140
 141     public void assertFieldValue( String fieldValue, String fieldName )
 142     {
 143         assertElementPresent( fieldName );
 144         Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
 145     }
 146
 147     public void assertPage( String title )
 148     {
 149         Assert.assertEquals( getTitle(), title );
 150     }
 151
 152     public String getTitle()
 153     {
 154         // Collapse spaces
 155         return getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
 156     }
 157
 158     public String getHtmlContent()
 159     {
 160         return getSelenium().getHtmlSource();
 161     }
 162
 163     public String getText( String locator )
 164     {
 165         return getSelenium().getText( locator );
 166     }
 167
 168     public void assertTextPresent( String text )
 169     {
 170         Assert.assertTrue( getSelenium().isTextPresent( text ), "'" + text + "' isn't present." );
 171     }
 172
 173     /**
 174      * one of text args must be in the page so use en and fr text (olamy use en locale :-) )
 175      *
 176      * @param texts
 177      */
 178     public void assertTextPresent( String... texts )
 179     {
 180         boolean present = false;
 181         StringBuilder sb = new StringBuilder();
 182         for ( String text : texts )
 183         {
 184             present = present || getSelenium().isTextPresent( text );
 185             sb.append( " " + text + " " );
 186         }
 187         Assert.assertTrue( present, "'one of the following test " + sb.toString() + "' isn't present." );
 188     }
 189
 190     public void assertTextNotPresent( String text )
 191     {
 192         Assert.assertFalse( getSelenium().isTextPresent( text ), "'" + text + "' is present." );
 193     }
 194
 195     public void assertElementPresent( String elementLocator )
 196     {
 197         Assert.assertTrue( isElementPresent( elementLocator ), "'" + elementLocator + "' isn't present." );
 198     }
 199
 200     public void assertElementNotPresent( String elementLocator )
 201     {
 202         Assert.assertFalse( isElementPresent( elementLocator ), "'" + elementLocator + "' is present." );
 203     }
 204
 205     public void assertLinkPresent( String text )
 206     {
 207         Assert.assertTrue( isElementPresent( "link=" + text ), "The link '" + text + "' isn't present." );
 208     }
 209
 210     public void assertLinkNotPresent( String text )
 211     {
 212         Assert.assertFalse( isElementPresent( "link=" + text ), "The link('" + text + "' is present." );
 213     }
 214
 215     public void assertImgWithAlt( String alt )
 216     {
 217         assertElementPresent( "/¯img[@alt='" + alt + "']" );
 218     }
 219
 220     public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 221     {
 222         String locator = "//tr[" + row + "]/td[" + column + "]/";
 223         locator += isALink ? "a/" : "";
 224         locator += "img[@alt='" + alt + "']";
 225
 226         assertElementPresent( locator );
 227     }
 228
 229     public void assertImgWithAltNotPresent( String alt )
 230     {
 231         assertElementNotPresent( "/¯img[@alt='" + alt + "']" );
 232     }
 233
 234     public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 235     {
 236         Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 237     }
 238
 239     public boolean isTextPresent( String text )
 240     {
 241         return getSelenium().isTextPresent( text );
 242     }
 243
 244     public boolean isLinkPresent( String text )
 245     {
 246         return isElementPresent( "link=" + text );
 247     }
 248
 249     public boolean isElementPresent( String locator )
 250     {
 251         return getSelenium().isElementPresent( locator );
 252     }
 253
 254     public void waitPage()
 255     {
 256         // TODO define a smaller maxWaitTimeJsInMs for wait javascript response for browser side validation
 257         getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 258         // http://jira.openqa.org/browse/SRC-302
 259         // those hack looks to break some tests :-(
 260         // getSelenium().waitForCondition( "selenium.isElementPresent('document.body');", maxWaitTimeInMs );
 261         //getSelenium().waitForCondition( "selenium.isElementPresent('footer');", maxWaitTimeInMs );
 262         //getSelenium().waitForCondition( "selenium.browserbot.getCurrentWindow().document.getElementById('footer')",
 263         //                                maxWaitTimeInMs );
 264         // so the only hack is to not use a too small wait time
 265         /*
 266         try
 267         {
 268             Thread.sleep( 1000 );
 269         }
 270         catch ( InterruptedException e )
 271         {
 272             throw new RuntimeException( "issue on Thread.sleep : " + e.getMessage(), e );
 273         }*/
 274     }
 275
 276     public String getFieldValue( String fieldName )
 277     {
 278         return getSelenium().getValue( fieldName );
 279     }
 280
 281     public String getCellValueFromTable( String tableElement, int row, int column )
 282     {
 283         return getSelenium().getTable( tableElement + "." + row + "." + column );
 284     }
 285
 286     public void selectValue( String locator, String value )
 287     {
 288         getSelenium().select( locator, "label=" + value );
 289     }
 290
 291
 292     public void assertOptionPresent( String selectField, String[] options )
 293     {
 294         assertElementPresent( selectField );
 295         String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 296         List<String> expected = Arrays.asList( options );
 297         List<String> present = Arrays.asList( optionsPresent );
 298         Assert.assertTrue( present.containsAll( expected ), "Options expected are not included in present options" );
 299     }
 300
 301     public void assertSelectedValue( String value, String fieldName )
 302     {
 303         assertElementPresent( fieldName );
 304         String optionsPresent = getSelenium().getSelectedLabel( value );
 305         Assert.assertEquals( optionsPresent, value );
 306     }
 307
 308     public void submit()
 309     {
 310         clickLinkWithXPath( "//input[@type='submit']" );
 311     }
 312
 313     public void assertButtonWithValuePresent( String text )
 314     {
 315         Assert.assertTrue( isButtonWithValuePresent( text ), "'" + text + "' button isn't present" );
 316     }
 317
 318     public void assertButtonWithIdPresent( String id )
 319     {
 320         Assert.assertTrue( isButtonWithIdPresent( id ), "'Button with id =" + id + "' isn't present" );
 321     }
 322
 323     public void assertButtonWithValueNotPresent( String text )
 324     {
 325         Assert.assertFalse( isButtonWithValuePresent( text ), "'" + text + "' button is present" );
 326     }
 327
 328     public boolean isButtonWithValuePresent( String text )
 329     {
 330         return isElementPresent( "//button[@value='" + text + "']" ) || isElementPresent(
 331             "//input[@value='" + text + "']" );
 332     }
 333
 334     public boolean isButtonWithIdPresent( String text )
 335     {
 336         return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 337     }
 338
 339     public void clickButtonWithName( String text, boolean wait )
 340     {
 341         clickLinkWithXPath( "//input[@name='" + text + "']", wait );
 342     }
 343
 344     public void clickButtonWithValue( String text )
 345     {
 346         clickButtonWithValue( text, true );
 347     }
 348
 349     public void clickButtonWithValue( String text, boolean wait )
 350     {
 351         assertButtonWithValuePresent( text );
 352
 353         if ( isElementPresent( "//button[@value='" + text + "']" ) )
 354         {
 355             clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 356         }
 357         else
 358         {
 359             clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 360         }
 361     }
 362
 363     public void clickSubmitWithLocator( String locator )
 364     {
 365         clickLinkWithLocator( locator );
 366     }
 367
 368     public void clickSubmitWithLocator( String locator, boolean wait )
 369     {
 370         clickLinkWithLocator( locator, wait );
 371     }
 372
 373     public void clickImgWithAlt( String alt )
 374     {
 375         clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 376     }
 377
 378     public void clickLinkWithText( String text )
 379     {
 380         clickLinkWithText( text, true );
 381     }
 382
 383     public void clickLinkWithText( String text, boolean wait )
 384     {
 385         clickLinkWithLocator( "link=" + text, wait );
 386     }
 387
 388     public void clickLinkWithXPath( String xpath )
 389     {
 390         clickLinkWithXPath( xpath, true );
 391     }
 392
 393     public void clickLinkWithXPath( String xpath, boolean wait )
 394     {
 395         clickLinkWithLocator( "xpath=" + xpath, wait );
 396     }
 397
 398     public void clickLinkWithLocator( String locator )
 399     {
 400         clickLinkWithLocator( locator, true );
 401     }
 402
 403     public void clickLinkWithLocator( String locator, boolean wait )
 404     {
 405         assertElementPresent( locator );
 406         getSelenium().click( locator );
 407         if ( wait )
 408         {
 409             waitPage();
 410         }
 411     }
 412
 413     public void clickButtonWithLocator( String locator )
 414     {
 415         clickButtonWithLocator( locator, true );
 416     }
 417
 418     public void clickButtonWithLocator( String locator, boolean wait )
 419     {
 420         assertElementPresent( locator );
 421         getSelenium().click( locator );
 422         if ( wait )
 423         {
 424             waitPage();
 425         }
 426     }
 427
 428     public void setFieldValues( Map<String, String> fieldMap )
 429     {
 430         Map.Entry<String, String> entry;
 431
 432         for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 433         {
 434             entry = entries.next();
 435
 436             getSelenium().type( entry.getKey(), entry.getValue() );
 437         }
 438     }
 439
 440     public void setFieldValue( String fieldName, String value )
 441     {
 442         getSelenium().type( fieldName, value );
 443     }
 444
 445     public void checkField( String locator )
 446     {
 447         getSelenium().check( locator );
 448     }
 449
 450     public void uncheckField( String locator )
 451     {
 452         getSelenium().uncheck( locator );
 453     }
 454
 455     public boolean isChecked( String locator )
 456     {
 457         return getSelenium().isChecked( locator );
 458     }
 459
 460     public void assertIsChecked( String locator )
 461     {
 462         Assert.assertTrue( getSelenium().isChecked( locator ) );
 463     }
 464
 465     public void assertIsNotChecked( String locator )
 466     {
 467         Assert.assertFalse( getSelenium().isChecked( locator ) );
 468     }
 469
 470     public void assertXpathCount( String locator, int expectedCount )
 471     {
 472         int count = getSelenium().getXpathCount( locator ).intValue();
 473         Assert.assertEquals( count, expectedCount );
 474     }
 475
 476     public void assertElementValue( String locator, String expectedValue )
 477     {
 478         Assert.assertEquals( getSelenium().getValue( locator ), expectedValue );
 479     }
 480
 481 }