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