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 boolean isElementVisible( String locator )
 255     {
 256         return getSelenium().isVisible( locator );
 257     }
 258
 259
 260     public void waitPage()
 261     {
 262         // TODO define a smaller maxWaitTimeJsInMs for wait javascript response for browser side validation
 263         //getSelenium().w .wait( Long.parseLong( maxWaitTimeInMs ) );
 264         //getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 265         // http://jira.openqa.org/browse/SRC-302
 266         // those hack looks to break some tests :-(
 267         // getSelenium().waitForCondition( "selenium.isElementPresent('document.body');", maxWaitTimeInMs );
 268         //getSelenium().waitForCondition( "selenium.isElementPresent('footer');", maxWaitTimeInMs );
 269         //getSelenium().waitForCondition( "selenium.browserbot.getCurrentWindow().document.getElementById('footer')",
 270         //                                maxWaitTimeInMs );
 271         // so the only hack is to not use a too small wait time
 272
 273         try
 274         {
 275             Thread.sleep( Long.parseLong( maxWaitTimeInMs ) );
 276         }
 277         catch ( InterruptedException e )
 278         {
 279             throw new RuntimeException( "issue on Thread.sleep : " + e.getMessage(), e );
 280         }
 281     }
 282
 283     public String getFieldValue( String fieldName )
 284     {
 285         return getSelenium().getValue( fieldName );
 286     }
 287
 288     public String getCellValueFromTable( String tableElement, int row, int column )
 289     {
 290         return getSelenium().getTable( tableElement + "." + row + "." + column );
 291     }
 292
 293     public void selectValue( String locator, String value )
 294     {
 295         getSelenium().select( locator, "label=" + value );
 296     }
 297
 298
 299     public void assertOptionPresent( String selectField, String[] options )
 300     {
 301         assertElementPresent( selectField );
 302         String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 303         List<String> expected = Arrays.asList( options );
 304         List<String> present = Arrays.asList( optionsPresent );
 305         Assert.assertTrue( present.containsAll( expected ), "Options expected are not included in present options" );
 306     }
 307
 308     public void assertSelectedValue( String value, String fieldName )
 309     {
 310         assertElementPresent( fieldName );
 311         String optionsPresent = getSelenium().getSelectedLabel( value );
 312         Assert.assertEquals( optionsPresent, value );
 313     }
 314
 315     public void submit()
 316     {
 317         clickLinkWithXPath( "//input[@type='submit']" );
 318     }
 319
 320     public void assertButtonWithValuePresent( String text )
 321     {
 322         Assert.assertTrue( isButtonWithValuePresent( text ), "'" + text + "' button isn't present" );
 323     }
 324
 325     public void assertButtonWithIdPresent( String id )
 326     {
 327         Assert.assertTrue( isButtonWithIdPresent( id ), "'Button with id =" + id + "' isn't present" );
 328     }
 329
 330     public void assertButtonWithValueNotPresent( String text )
 331     {
 332         Assert.assertFalse( isButtonWithValuePresent( text ), "'" + text + "' button is present" );
 333     }
 334
 335     public boolean isButtonWithValuePresent( String text )
 336     {
 337         return isElementPresent( "//button[@value='" + text + "']" ) || isElementPresent(
 338             "//input[@value='" + text + "']" );
 339     }
 340
 341     public boolean isButtonWithIdPresent( String text )
 342     {
 343         return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 344     }
 345
 346     public void clickButtonWithName( String text, boolean wait )
 347     {
 348         clickLinkWithXPath( "//input[@name='" + text + "']", wait );
 349     }
 350
 351     public void clickButtonWithValue( String text )
 352     {
 353         clickButtonWithValue( text, true );
 354     }
 355
 356     public void clickButtonWithValue( String text, boolean wait )
 357     {
 358         assertButtonWithValuePresent( text );
 359
 360         if ( isElementPresent( "//button[@value='" + text + "']" ) )
 361         {
 362             clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 363         }
 364         else
 365         {
 366             clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 367         }
 368     }
 369
 370     public void clickSubmitWithLocator( String locator )
 371     {
 372         clickLinkWithLocator( locator );
 373     }
 374
 375     public void clickSubmitWithLocator( String locator, boolean wait )
 376     {
 377         clickLinkWithLocator( locator, wait );
 378     }
 379
 380     public void clickImgWithAlt( String alt )
 381     {
 382         clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 383     }
 384
 385     public void clickLinkWithText( String text )
 386     {
 387         clickLinkWithText( text, true );
 388     }
 389
 390     public void clickLinkWithText( String text, boolean wait )
 391     {
 392         clickLinkWithLocator( "link=" + text, wait );
 393     }
 394
 395     public void clickLinkWithXPath( String xpath )
 396     {
 397         clickLinkWithXPath( xpath, true );
 398     }
 399
 400     public void clickLinkWithXPath( String xpath, boolean wait )
 401     {
 402         clickLinkWithLocator( "xpath=" + xpath, wait );
 403     }
 404
 405     public void clickLinkWithLocator( String locator )
 406     {
 407         clickLinkWithLocator( locator, true );
 408     }
 409
 410     public void clickLinkWithLocator( String locator, boolean wait )
 411     {
 412         assertElementPresent( locator );
 413         getSelenium().click( locator );
 414         if ( wait )
 415         {
 416             waitPage();
 417         }
 418     }
 419
 420     public void clickButtonWithLocator( String locator )
 421     {
 422         clickButtonWithLocator( locator, true );
 423     }
 424
 425     public void clickButtonWithLocator( String locator, boolean wait )
 426     {
 427         assertElementPresent( locator );
 428         getSelenium().click( locator );
 429         if ( wait )
 430         {
 431             waitPage();
 432         }
 433     }
 434
 435     public void setFieldValues( Map<String, String> fieldMap )
 436     {
 437         Map.Entry<String, String> entry;
 438
 439         for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 440         {
 441             entry = entries.next();
 442
 443             getSelenium().type( entry.getKey(), entry.getValue() );
 444         }
 445     }
 446
 447     public void setFieldValue( String fieldName, String value )
 448     {
 449         getSelenium().type( fieldName, value );
 450     }
 451
 452     public void checkField( String locator )
 453     {
 454         getSelenium().check( locator );
 455     }
 456
 457     public void uncheckField( String locator )
 458     {
 459         getSelenium().uncheck( locator );
 460     }
 461
 462     public boolean isChecked( String locator )
 463     {
 464         return getSelenium().isChecked( locator );
 465     }
 466
 467     public void assertIsChecked( String locator )
 468     {
 469         Assert.assertTrue( getSelenium().isChecked( locator ) );
 470     }
 471
 472     public void assertIsNotChecked( String locator )
 473     {
 474         Assert.assertFalse( getSelenium().isChecked( locator ) );
 475     }
 476
 477     public void assertXpathCount( String locator, int expectedCount )
 478     {
 479         int count = getSelenium().getXpathCount( locator ).intValue();
 480         Assert.assertEquals( count, expectedCount );
 481     }
 482
 483     public void assertElementValue( String locator, String expectedValue )
 484     {
 485         Assert.assertEquals( getSelenium().getValue( locator ), expectedValue );
 486     }
 487
 488 }