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