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.util.Arrays;
  23 import java.util.Iterator;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Properties;
  27 import java.util.Map.Entry;
  28
  29 import org.codehaus.plexus.util.StringUtils;
  30
  31 import org.testng.Assert;
  32 import com.thoughtworks.selenium.DefaultSelenium;
  33 import com.thoughtworks.selenium.Selenium;
  34
  35 /**
  36  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  37  * @version $Id: AbstractSeleniumTestCase.java 761154 2009-04-02 03:31:19Z wsmoak $
  38  */
  39
  40 public abstract class AbstractSeleniumTest {
  41
  42         public static String baseUrl;
  43
  44     public static String maxWaitTimeInMs;
  45
  46     private static ThreadLocal<Selenium> selenium;
  47
  48     public static Properties p;
  49
  50     public void open()
  51             throws Exception
  52         {
  53             p = new Properties();
  54             p.load( this.getClass().getClassLoader().getResourceAsStream( "testng.properties" ) );
  55
  56             baseUrl = p.getProperty( "BASE_URL" );
  57             maxWaitTimeInMs = p.getProperty( "MAX_WAIT_TIME_IN_MS" );
  58
  59             String seleniumHost = p.getProperty( "SELENIUM_HOST" );
  60             int seleniumPort = Integer.parseInt( ( p.getProperty( "SELENIUM_PORT" ) ) );
  61
  62         String seleniumBrowser = System.getProperty( "browser" );
  63         if ( StringUtils.isEmpty( seleniumBrowser ) )
  64         {
  65             seleniumBrowser = p.getProperty( "SELENIUM_BROWSER" );
  66         }
  67
  68             final Selenium s = new DefaultSelenium( seleniumHost, seleniumPort, seleniumBrowser, baseUrl );
  69             selenium = new ThreadLocal<Selenium>()
  70             {
  71                 protected Selenium initialValue()
  72                 {
  73                     return s;
  74                 }
  75             };
  76             getSelenium().start();
  77         }
  78
  79         protected static Selenium getSelenium()
  80         {
  81             return selenium.get();
  82         }
  83
  84             public void close()
  85             throws Exception
  86         {
  87             getSelenium().stop();
  88         }
  89
  90         // *******************************************************
  91         // Auxiliar methods. This method help us and simplify test.
  92         // *******************************************************
  93
  94         public void assertFieldValue( String fieldValue, String fieldName )
  95         {
  96             assertElementPresent( fieldName );
  97             Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
  98         }
  99
 100         public void assertPage( String title )
 101         {
 102             Assert.assertEquals( getSelenium().getTitle(), title );
 103         }
 104
 105         public String getTitle()
 106         {
 107             return getSelenium().getTitle();
 108         }
 109
 110         public String getHtmlContent()
 111         {
 112             return getSelenium().getHtmlSource();
 113         }
 114
 115         public void assertTextPresent( String text )
 116         {
 117             Assert.assertTrue( getSelenium().isTextPresent( text ), "'" + text + "' isn't present." );
 118         }
 119
 120         public void assertTextNotPresent( String text )
 121         {
 122             Assert.assertFalse( getSelenium().isTextPresent( text ), "'" + text + "' is present." );
 123         }
 124
 125         public void assertElementPresent( String elementLocator )
 126         {
 127             Assert.assertTrue( isElementPresent( elementLocator ), "'" + elementLocator + "' isn't present." );
 128         }
 129
 130         public void assertElementNotPresent( String elementLocator )
 131         {
 132             Assert.assertFalse( isElementPresent( elementLocator ), "'" + elementLocator + "' is present." );
 133         }
 134
 135         public void assertLinkPresent( String text )
 136         {
 137                 Assert.assertTrue( isElementPresent( "link=" + text ), "The link '" + text + "' isî't present." );
 138         }
 139
 140         public void assertLinkNotPresenu( String text )
 141         {
 142                 Assert.assertFalse( isElementPresent( "link=" + text ), "The link('" + text + "' is present." );
 143         }
 144
 145         public void assertImgWithAlt( String alt )
 146         {
 147             assertElementPresent( "/¯img[@alt='" + alt + "']" );
 148         }
 149
 150         public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 151         {
 152             String locator = "//tr[" + row + "]/td[" + column + "]/";
 153             locator += isALink ? "a/" : "";
 154             locator += "img[@alt='" + alt + "']";
 155
 156             assertElementPresent( locator );
 157         }
 158
 159         public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 160         {
 161             Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 162         }
 163
 164         public boolean isTextPresent( String text )
 165         {
 166             return getSelenium().isTextPresent( text );
 167         }
 168
 169         public boolean isLinkPresent( String text )
 170         {
 171             return isElementPresent( "link=" + text );
 172         }
 173
 174         public boolean isElementPresent( String locator )
 175         {
 176             return getSelenium().isElementPresent( locator );
 177         }
 178
 179         public void waitPage()
 180         {
 181             getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 182         }
 183
 184         public String getFieldValue( String fieldName )
 185         {
 186             return getSelenium().getValue( fieldName );
 187         }
 188
 189         public String getCellValueFromTable( String tableElement, int row, int column )
 190         {
 191             return getSelenium().getTable( tableElement + "." + row + "." + column );
 192         }
 193
 194         public void selectValue( String locator, String value )
 195         {
 196             getSelenium().select( locator, "label=" + value );
 197         }
 198
 199         public void assertOptionPresent( String selectField, String[] options )
 200         {
 201             assertElementPresent( selectField );
 202             String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 203             List<String> expected = Arrays.asList( options );
 204         List<String> present = Arrays.asList( optionsPresent );
 205             Assert.assertTrue( present.containsAll( expected ), "Options expected are not included in present options" );
 206         }
 207
 208         public void assertSelectedValue( String value, String fieldName )
 209         {
 210             assertElementPresent( fieldName );
 211             String optionsPresent = getSelenium().getSelectedLabel( value );
 212             Assert.assertEquals( optionsPresent, value );
 213         }
 214
 215         public void submit()
 216         {
 217             clickLinkWithXPath( "//input[@type='submit']" );
 218         }
 219
 220         public void assertButtonWithValuePresent( String text )
 221         {
 222             Assert.assertTrue( isButtonWithValuePresent( text ), "'" + text + "' button isn't present" );
 223         }
 224
 225         public void assertButtonWithIdPresent( String id )
 226         {
 227             Assert.assertTrue( isButtonWithIdPresent( id ), "'Button with id =" + id + "' isn't present" );
 228         }
 229
 230         public void assertButtonWithValueNotPresent( String text )
 231         {
 232             Assert.assertFalse( isButtonWithValuePresent( text ), "'" + text + "' button is present" );
 233         }
 234
 235         public boolean isButtonWithValuePresent( String text )
 236         {
 237             return isElementPresent( "//button[@value='" + text + "']" )
 238                 || isElementPresent( "//input[@value='" + text + "']" );
 239         }
 240
 241         public boolean isButtonWithIdPresent( String text )
 242         {
 243             return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 244         }
 245
 246         public void clickButtonWithValue( String text )
 247         {
 248             clickButtonWithValue( text, true );
 249         }
 250
 251         public void clickButtonWithValue( String text, boolean wait )
 252         {
 253             assertButtonWithValuePresent( text );
 254
 255             if ( isElementPresent( "//button[@value='" + text + "']" ) )
 256             {
 257                 clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 258             }
 259             else
 260             {
 261                 clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 262             }
 263         }
 264
 265         public void clickSubmitWithLocator( String locator )
 266         {
 267             clickLinkWithLocator( locator );
 268         }
 269
 270         public void clickSubmitWithLocator( String locator, boolean wait )
 271         {
 272             clickLinkWithLocator( locator, wait );
 273         }
 274
 275         public void clickImgWithAlt( String alt )
 276         {
 277             clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 278         }
 279
 280         public void clickLinkWithText( String text )
 281         {
 282             clickLinkWithText( text, true );
 283         }
 284
 285         public void clickLinkWithText( String text, boolean wait )
 286         {
 287             clickLinkWithLocator( "link=" + text, wait );
 288         }
 289
 290         public void clickLinkWithXPath( String xpath )
 291         {
 292             clickLinkWithXPath( xpath, true );
 293         }
 294
 295         public void clickLinkWithXPath( String xpath, boolean wait )
 296         {
 297             clickLinkWithLocator( "xpath=" + xpath, wait );
 298         }
 299
 300         public void clickLinkWithLocator( String locator )
 301         {
 302             clickLinkWithLocator( locator, true );
 303         }
 304
 305         public void clickLinkWithLocator( String locator, boolean wait )
 306         {
 307             assertElementPresent( locator );
 308             getSelenium().click( locator );
 309             if ( wait )
 310             {
 311                 waitPage();
 312             }
 313         }
 314
 315         public void setFieldValues( Map<String, String> fieldMap )
 316         {
 317             Map.Entry<String, String> entry;
 318
 319             for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 320             {
 321                 entry = entries.next();
 322
 323                 getSelenium().type( entry.getKey(), entry.getValue() );
 324             }
 325         }
 326
 327         public void setFieldValue( String fieldName, String value )
 328         {
 329             getSelenium().type( fieldName, value );
 330         }
 331
 332         public void checkField( String locator )
 333         {
 334             getSelenium().check( locator );
 335         }
 336
 337         public void uncheckField( String locator )
 338         {
 339             getSelenium().uncheck( locator );
 340         }
 341
 342         public boolean isChecked( String locator )
 343         {
 344             return getSelenium().isChecked( locator );
 345         }
 346
 347         public void assertIsChecked( String locator )
 348         {
 349             Assert.assertTrue( getSelenium().isChecked( locator ) );
 350         }
 351
 352         public void assertIsNotChecked( String locator )
 353         {
 354             Assert.assertFalse( getSelenium().isChecked( locator ) );
 355         }
 356
 357 }