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.Properties;
  30 import java.util.Map.Entry;
  31
  32 import org.apache.commons.io.IOUtils;
  33 import org.testng.Assert;
  34
  35 import com.thoughtworks.selenium.DefaultSelenium;
  36 import com.thoughtworks.selenium.Selenium;
  37
  38 /**
  39  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  40  * @version $Id: AbstractSeleniumTestCase.java 761154 2009-04-02 03:31:19Z wsmoak $
  41  */
  42
  43 public abstract class AbstractSeleniumTest {
  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             /**
 119      * Close selenium session. Called from AfterSuite method of sub-class
 120      */
 121     public void close()
 122         throws Exception
 123     {
 124         if ( getSelenium() != null )
 125         {
 126             getSelenium().stop();
 127             selenium.set( null );
 128         }
 129     }
 130
 131         // *******************************************************
 132         // Auxiliar methods. This method help us and simplify test.
 133         // *******************************************************
 134
 135         public void assertFieldValue( String fieldValue, String fieldName )
 136         {
 137                         assertElementPresent( fieldName );
 138                         Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
 139         }
 140
 141     public void assertPage( String title )
 142     {
 143         Assert.assertEquals( getTitle(), title );
 144     }
 145
 146         public String getTitle()
 147         {
 148             // Collapse spaces
 149             return getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
 150         }
 151
 152         public String getHtmlContent()
 153         {
 154             return getSelenium().getHtmlSource();
 155         }
 156
 157         public void assertTextPresent( String text )
 158         {
 159             Assert.assertTrue( getSelenium().isTextPresent( text ), "'" + text + "' isn't present." );
 160         }
 161
 162         public void assertTextNotPresent( String text )
 163         {
 164             Assert.assertFalse( getSelenium().isTextPresent( text ), "'" + text + "' is present." );
 165         }
 166
 167         public void assertElementPresent( String elementLocator )
 168         {
 169            Assert.assertTrue( isElementPresent( elementLocator ), "'" + elementLocator + "' isn't present." );
 170         }
 171
 172         public void assertElementNotPresent( String elementLocator )
 173         {
 174            Assert.assertFalse( isElementPresent( elementLocator ), "'" + elementLocator + "' is present." );
 175         }
 176
 177         public void assertLinkPresent( String text )
 178         {
 179            Assert.assertTrue( isElementPresent( "link=" + text ), "The link '" + text + "' isî't present." );
 180         }
 181
 182         public void assertLinkNotPresent( String text )
 183         {
 184            Assert.assertFalse( isElementPresent( "link=" + text ), "The link('" + text + "' is present." );
 185         }
 186
 187         public void assertImgWithAlt( String alt )
 188         {
 189            assertElementPresent( "/¯img[@alt='" + alt + "']" );
 190         }
 191
 192         public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 193         {
 194             String locator = "//tr[" + row + "]/td[" + column + "]/";
 195             locator += isALink ? "a/" : "";
 196             locator += "img[@alt='" + alt + "']";
 197
 198             assertElementPresent( locator );
 199         }
 200
 201         public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 202         {
 203             Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 204         }
 205
 206         public boolean isTextPresent( String text )
 207         {
 208             return getSelenium().isTextPresent( text );
 209         }
 210
 211         public boolean isLinkPresent( String text )
 212         {
 213             return isElementPresent( "link=" + text );
 214         }
 215
 216         public boolean isElementPresent( String locator )
 217         {
 218             return getSelenium().isElementPresent( locator );
 219         }
 220
 221         public void waitPage()
 222         {
 223             getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 224         }
 225
 226         public String getFieldValue( String fieldName )
 227         {
 228             return getSelenium().getValue( fieldName );
 229         }
 230
 231         public String getCellValueFromTable( String tableElement, int row, int column )
 232         {
 233             return getSelenium().getTable( tableElement + "." + row + "." + column );
 234         }
 235
 236         public void selectValue( String locator, String value )
 237         {
 238             getSelenium().select( locator, "label=" + value );
 239         }
 240
 241         public void assertOptionPresent( String selectField, String[] options )
 242         {
 243             assertElementPresent( selectField );
 244             String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 245             List<String> expected = Arrays.asList( options );
 246         List<String> present = Arrays.asList( optionsPresent );
 247             Assert.assertTrue( present.containsAll( expected ), "Options expected are not included in present options" );
 248         }
 249
 250         public void assertSelectedValue( String value, String fieldName )
 251         {
 252             assertElementPresent( fieldName );
 253             String optionsPresent = getSelenium().getSelectedLabel( value );
 254             Assert.assertEquals( optionsPresent, value );
 255         }
 256
 257         public void submit()
 258         {
 259             clickLinkWithXPath( "//input[@type='submit']" );
 260         }
 261
 262         public void assertButtonWithValuePresent( String text )
 263         {
 264             Assert.assertTrue( isButtonWithValuePresent( text ), "'" + text + "' button isn't present" );
 265         }
 266
 267         public void assertButtonWithIdPresent( String id )
 268         {
 269             Assert.assertTrue( isButtonWithIdPresent( id ), "'Button with id =" + id + "' isn't present" );
 270         }
 271
 272         public void assertButtonWithValueNotPresent( String text )
 273         {
 274            Assert.assertFalse( isButtonWithValuePresent( text ), "'" + text + "' button is present" );
 275         }
 276
 277         public boolean isButtonWithValuePresent( String text )
 278         {
 279             return isElementPresent( "//button[@value='" + text + "']" )
 280                 || isElementPresent( "//input[@value='" + text + "']" );
 281         }
 282
 283         public boolean isButtonWithIdPresent( String text )
 284         {
 285             return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 286         }
 287
 288         public void clickButtonWithValue( String text )
 289         {
 290             clickButtonWithValue( text, true );
 291         }
 292
 293         public void clickButtonWithValue( String text, boolean wait )
 294         {
 295             assertButtonWithValuePresent( text );
 296
 297             if ( isElementPresent( "//button[@value='" + text + "']" ) )
 298             {
 299                 clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 300             }
 301             else
 302             {
 303                 clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 304             }
 305         }
 306
 307         public void clickSubmitWithLocator( String locator )
 308         {
 309             clickLinkWithLocator( locator );
 310         }
 311
 312         public void clickSubmitWithLocator( String locator, boolean wait )
 313         {
 314             clickLinkWithLocator( locator, wait );
 315         }
 316
 317         public void clickImgWithAlt( String alt )
 318         {
 319             clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 320         }
 321
 322         public void clickLinkWithText( String text )
 323         {
 324             clickLinkWithText( text, true );
 325         }
 326
 327         public void clickLinkWithText( String text, boolean wait )
 328         {
 329             clickLinkWithLocator( "link=" + text, wait );
 330         }
 331
 332         public void clickLinkWithXPath( String xpath )
 333         {
 334             clickLinkWithXPath( xpath, true );
 335         }
 336
 337         public void clickLinkWithXPath( String xpath, boolean wait )
 338         {
 339             clickLinkWithLocator( "xpath=" + xpath, wait );
 340         }
 341
 342         public void clickLinkWithLocator( String locator )
 343         {
 344             clickLinkWithLocator( locator, true );
 345         }
 346
 347         public void clickLinkWithLocator( String locator, boolean wait )
 348         {
 349             assertElementPresent( locator );
 350             getSelenium().click( locator );
 351             if ( wait )
 352             {
 353                 waitPage();
 354             }
 355         }
 356
 357         public void setFieldValues( Map<String, String> fieldMap )
 358         {
 359             Map.Entry<String, String> entry;
 360
 361             for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 362             {
 363                 entry = entries.next();
 364
 365                 getSelenium().type( entry.getKey(), entry.getValue() );
 366             }
 367         }
 368
 369         public void setFieldValue( String fieldName, String value )
 370         {
 371             getSelenium().type( fieldName, value );
 372         }
 373
 374         public void checkField( String locator )
 375         {
 376             getSelenium().check( locator );
 377         }
 378
 379         public void uncheckField( String locator )
 380         {
 381             getSelenium().uncheck( locator );
 382         }
 383
 384         public boolean isChecked( String locator )
 385         {
 386             return getSelenium().isChecked( locator );
 387         }
 388
 389         public void assertIsChecked( String locator )
 390         {
 391             Assert.assertTrue( getSelenium().isChecked( locator ) );
 392         }
 393
 394         public void assertIsNotChecked( String locator )
 395         {
 396            Assert.assertFalse( getSelenium().isChecked( locator ) );
 397         }
 398
 399 }