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 java.io.IOException;
  23 import java.io.InputStream;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.Iterator;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Map.Entry;
  30 import java.util.Properties;
  31
  32 import com.thoughtworks.selenium.DefaultSelenium;
  33 import com.thoughtworks.selenium.Selenium;
  34 import org.apache.commons.io.IOUtils;
  35 import org.testng.Assert;
  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         // baseUrl = getProperty( "BASE_URL" );
  62         maxWaitTimeInMs = getProperty( "MAX_WAIT_TIME_IN_MS" );
  63     }
  64
  65     /**
  66      * Initialize selenium
  67      */
  68     public void open( String baseUrl, String browser, String seleniumHost, int seleniumPort )
  69         throws Exception
  70     {
  71         this.baseUrl = baseUrl;
  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
  82     public static Selenium getSelenium()
  83     {
  84         return selenium == null ? null : selenium.get();
  85     }
  86
  87     protected String getProperty( String key )
  88     {
  89         return p.getProperty( key );
  90     }
  91
  92     protected String getEscapeProperty( String key )
  93     {
  94         InputStream input = this.getClass().getClassLoader().getResourceAsStream( "testng.properties" );
  95         String value = null;
  96         List<String> lines;
  97         try
  98         {
  99             lines = IOUtils.readLines( input );
 100         }
 101         catch ( IOException e )
 102         {
 103             lines = new ArrayList<String>();
 104         }
 105         for ( String l : lines )
 106         {
 107             if ( l != null && l.startsWith( key ) )
 108             {
 109                 int indexSeparator = l.indexOf( PROPERTIES_SEPARATOR );
 110                 value = l.substring( indexSeparator + 1 ).trim();
 111                 break;
 112             }
 113         }
 114         return value;
 115     }
 116
 117     /**
 118      * Close selenium session. Called from AfterSuite method of sub-class
 119      */
 120     public void close()
 121         throws Exception
 122     {
 123         if ( getSelenium() != null )
 124         {
 125             getSelenium().stop();
 126             selenium.set( null );
 127         }
 128     }
 129
 130     // *******************************************************
 131     // Auxiliar methods. This method help us and simplify test.
 132     // *******************************************************
 133
 134     public void assertFieldValue( String fieldValue, String fieldName )
 135     {
 136         assertElementPresent( fieldName );
 137         Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
 138     }
 139
 140     public void assertPage( String title )
 141     {
 142         Assert.assertEquals( getTitle(), title );
 143     }
 144
 145     public String getTitle()
 146     {
 147         // Collapse spaces
 148         return getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
 149     }
 150
 151     public String getHtmlContent()
 152     {
 153         return getSelenium().getHtmlSource();
 154     }
 155
 156     public String getText( String locator )
 157     {
 158         return getSelenium().getText( locator );
 159     }
 160
 161     public void assertTextPresent( String text )
 162     {
 163         Assert.assertTrue( getSelenium().isTextPresent( text ), "'" + text + "' isn't present." );
 164     }
 165
 166     public void assertTextNotPresent( String text )
 167     {
 168         Assert.assertFalse( getSelenium().isTextPresent( text ), "'" + text + "' is present." );
 169     }
 170
 171     public void assertElementPresent( String elementLocator )
 172     {
 173         Assert.assertTrue( isElementPresent( elementLocator ), "'" + elementLocator + "' isn't present." );
 174     }
 175
 176     public void assertElementNotPresent( String elementLocator )
 177     {
 178         Assert.assertFalse( isElementPresent( elementLocator ), "'" + elementLocator + "' is present." );
 179     }
 180
 181     public void assertLinkPresent( String text )
 182     {
 183         Assert.assertTrue( isElementPresent( "link=" + text ), "The link '" + text + "' isn't present." );
 184     }
 185
 186     public void assertLinkNotPresent( String text )
 187     {
 188         Assert.assertFalse( isElementPresent( "link=" + text ), "The link('" + text + "' is present." );
 189     }
 190
 191     public void assertImgWithAlt( String alt )
 192     {
 193         assertElementPresent( "/¯img[@alt='" + alt + "']" );
 194     }
 195
 196     public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 197     {
 198         String locator = "//tr[" + row + "]/td[" + column + "]/";
 199         locator += isALink ? "a/" : "";
 200         locator += "img[@alt='" + alt + "']";
 201
 202         assertElementPresent( locator );
 203     }
 204
 205     public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 206     {
 207         Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 208     }
 209
 210     public boolean isTextPresent( String text )
 211     {
 212         return getSelenium().isTextPresent( text );
 213     }
 214
 215     public boolean isLinkPresent( String text )
 216     {
 217         return isElementPresent( "link=" + text );
 218     }
 219
 220     public boolean isElementPresent( String locator )
 221     {
 222         return getSelenium().isElementPresent( locator );
 223     }
 224
 225     public void waitPage()
 226     {
 227         getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 228     }
 229
 230     public String getFieldValue( String fieldName )
 231     {
 232         return getSelenium().getValue( fieldName );
 233     }
 234
 235     public String getCellValueFromTable( String tableElement, int row, int column )
 236     {
 237         return getSelenium().getTable( tableElement + "." + row + "." + column );
 238     }
 239
 240     public void selectValue( String locator, String value )
 241     {
 242         getSelenium().select( locator, "label=" + value );
 243     }
 244
 245     public void assertOptionPresent( String selectField, String[] options )
 246     {
 247         assertElementPresent( selectField );
 248         String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 249         List<String> expected = Arrays.asList( options );
 250         List<String> present = Arrays.asList( optionsPresent );
 251         Assert.assertTrue( present.containsAll( expected ), "Options expected are not included in present options" );
 252     }
 253
 254     public void assertSelectedValue( String value, String fieldName )
 255     {
 256         assertElementPresent( fieldName );
 257         String optionsPresent = getSelenium().getSelectedLabel( value );
 258         Assert.assertEquals( optionsPresent, value );
 259     }
 260
 261     public void submit()
 262     {
 263         clickLinkWithXPath( "//input[@type='submit']" );
 264     }
 265
 266     public void assertButtonWithValuePresent( String text )
 267     {
 268         Assert.assertTrue( isButtonWithValuePresent( text ), "'" + text + "' button isn't present" );
 269     }
 270
 271     public void assertButtonWithIdPresent( String id )
 272     {
 273         Assert.assertTrue( isButtonWithIdPresent( id ), "'Button with id =" + id + "' isn't present" );
 274     }
 275
 276     public void assertButtonWithValueNotPresent( String text )
 277     {
 278         Assert.assertFalse( isButtonWithValuePresent( text ), "'" + text + "' button is present" );
 279     }
 280
 281     public boolean isButtonWithValuePresent( String text )
 282     {
 283         return isElementPresent( "//button[@value='" + text + "']" )
 284             || isElementPresent( "//input[@value='" + text + "']" );
 285     }
 286
 287     public boolean isButtonWithIdPresent( String text )
 288     {
 289         return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 290     }
 291
 292     public void clickButtonWithValue( String text )
 293     {
 294         clickButtonWithValue( text, true );
 295     }
 296
 297     public void clickButtonWithValue( String text, boolean wait )
 298     {
 299         assertButtonWithValuePresent( text );
 300
 301         if ( isElementPresent( "//button[@value='" + text + "']" ) )
 302         {
 303             clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 304         }
 305         else
 306         {
 307             clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 308         }
 309     }
 310
 311     public void clickSubmitWithLocator( String locator )
 312     {
 313         clickLinkWithLocator( locator );
 314     }
 315
 316     public void clickSubmitWithLocator( String locator, boolean wait )
 317     {
 318         clickLinkWithLocator( locator, wait );
 319     }
 320
 321     public void clickImgWithAlt( String alt )
 322     {
 323         clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 324     }
 325
 326     public void clickLinkWithText( String text )
 327     {
 328         clickLinkWithText( text, true );
 329     }
 330
 331     public void clickLinkWithText( String text, boolean wait )
 332     {
 333         clickLinkWithLocator( "link=" + text, wait );
 334     }
 335
 336     public void clickLinkWithXPath( String xpath )
 337     {
 338         clickLinkWithXPath( xpath, true );
 339     }
 340
 341     public void clickLinkWithXPath( String xpath, boolean wait )
 342     {
 343         clickLinkWithLocator( "xpath=" + xpath, wait );
 344     }
 345
 346     public void clickLinkWithLocator( String locator )
 347     {
 348         clickLinkWithLocator( locator, true );
 349     }
 350
 351     public void clickLinkWithLocator( String locator, boolean wait )
 352     {
 353         assertElementPresent( locator );
 354         getSelenium().click( locator );
 355         if ( wait )
 356         {
 357             waitPage();
 358         }
 359     }
 360
 361     public void setFieldValues( Map<String, String> fieldMap )
 362     {
 363         Map.Entry<String, String> entry;
 364
 365         for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 366         {
 367             entry = entries.next();
 368
 369             getSelenium().type( entry.getKey(), entry.getValue() );
 370         }
 371     }
 372
 373     public void setFieldValue( String fieldName, String value )
 374     {
 375         getSelenium().type( fieldName, value );
 376     }
 377
 378     public void checkField( String locator )
 379     {
 380         getSelenium().check( locator );
 381     }
 382
 383     public void uncheckField( String locator )
 384     {
 385         getSelenium().uncheck( locator );
 386     }
 387
 388     public boolean isChecked( String locator )
 389     {
 390         return getSelenium().isChecked( locator );
 391     }
 392
 393     public void assertIsChecked( String locator )
 394     {
 395         Assert.assertTrue( getSelenium().isChecked( locator ) );
 396     }
 397
 398     public void assertIsNotChecked( String locator )
 399     {
 400         Assert.assertFalse( getSelenium().isChecked( locator ) );
 401     }
 402
 403 }