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