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         // Collapse spaces
 144         String actualTitle = getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
 145         Assert.assertEquals( actualTitle, title );
 146     }
 147
 148         public String getTitle()
 149         {
 150             return getSelenium().getTitle();
 151         }
 152
 153         public String getHtmlContent()
 154         {
 155             return getSelenium().getHtmlSource();
 156         }
 157
 158         public void assertTextPresent( String text )
 159         {
 160             Assert.assertTrue( getSelenium().isTextPresent( text ), "'" + text + "' isn't present." );
 161         }
 162
 163         public void assertTextNotPresent( String text )
 164         {
 165             Assert.assertFalse( getSelenium().isTextPresent( text ), "'" + text + "' is present." );
 166         }
 167
 168         public void assertElementPresent( String elementLocator )
 169         {
 170            Assert.assertTrue( isElementPresent( elementLocator ), "'" + elementLocator + "' isn't present." );
 171         }
 172
 173         public void assertElementNotPresent( String elementLocator )
 174         {
 175            Assert.assertFalse( isElementPresent( elementLocator ), "'" + elementLocator + "' is present." );
 176         }
 177
 178         public void assertLinkPresent( String text )
 179         {
 180            Assert.assertTrue( isElementPresent( "link=" + text ), "The link '" + text + "' isî't present." );
 181         }
 182
 183         public void assertLinkNotPresent( String text )
 184         {
 185            Assert.assertFalse( isElementPresent( "link=" + text ), "The link('" + text + "' is present." );
 186         }
 187
 188         public void assertImgWithAlt( String alt )
 189         {
 190            assertElementPresent( "/¯img[@alt='" + alt + "']" );
 191         }
 192
 193         public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 194         {
 195             String locator = "//tr[" + row + "]/td[" + column + "]/";
 196             locator += isALink ? "a/" : "";
 197             locator += "img[@alt='" + alt + "']";
 198
 199             assertElementPresent( locator );
 200         }
 201
 202         public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 203         {
 204             Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 205         }
 206
 207         public boolean isTextPresent( String text )
 208         {
 209             return getSelenium().isTextPresent( text );
 210         }
 211
 212         public boolean isLinkPresent( String text )
 213         {
 214             return isElementPresent( "link=" + text );
 215         }
 216
 217         public boolean isElementPresent( String locator )
 218         {
 219             return getSelenium().isElementPresent( locator );
 220         }
 221
 222         public void waitPage()
 223         {
 224             getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 225         }
 226
 227         public String getFieldValue( String fieldName )
 228         {
 229             return getSelenium().getValue( fieldName );
 230         }
 231
 232         public String getCellValueFromTable( String tableElement, int row, int column )
 233         {
 234             return getSelenium().getTable( tableElement + "." + row + "." + column );
 235         }
 236
 237         public void selectValue( String locator, String value )
 238         {
 239             getSelenium().select( locator, "label=" + value );
 240         }
 241
 242         public void assertOptionPresent( String selectField, String[] options )
 243         {
 244             assertElementPresent( selectField );
 245             String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 246             List<String> expected = Arrays.asList( options );
 247         List<String> present = Arrays.asList( optionsPresent );
 248             Assert.assertTrue( present.containsAll( expected ), "Options expected are not included in present options" );
 249         }
 250
 251         public void assertSelectedValue( String value, String fieldName )
 252         {
 253             assertElementPresent( fieldName );
 254             String optionsPresent = getSelenium().getSelectedLabel( value );
 255             Assert.assertEquals( optionsPresent, value );
 256         }
 257
 258         public void submit()
 259         {
 260             clickLinkWithXPath( "//input[@type='submit']" );
 261         }
 262
 263         public void assertButtonWithValuePresent( String text )
 264         {
 265             Assert.assertTrue( isButtonWithValuePresent( text ), "'" + text + "' button isn't present" );
 266         }
 267
 268         public void assertButtonWithIdPresent( String id )
 269         {
 270             Assert.assertTrue( isButtonWithIdPresent( id ), "'Button with id =" + id + "' isn't present" );
 271         }
 272
 273         public void assertButtonWithValueNotPresent( String text )
 274         {
 275            Assert.assertFalse( isButtonWithValuePresent( text ), "'" + text + "' button is present" );
 276         }
 277
 278         public boolean isButtonWithValuePresent( String text )
 279         {
 280             return isElementPresent( "//button[@value='" + text + "']" )
 281                 || isElementPresent( "//input[@value='" + text + "']" );
 282         }
 283
 284         public boolean isButtonWithIdPresent( String text )
 285         {
 286             return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 287         }
 288
 289         public void clickButtonWithValue( String text )
 290         {
 291             clickButtonWithValue( text, true );
 292         }
 293
 294         public void clickButtonWithValue( String text, boolean wait )
 295         {
 296             assertButtonWithValuePresent( text );
 297
 298             if ( isElementPresent( "//button[@value='" + text + "']" ) )
 299             {
 300                 clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 301             }
 302             else
 303             {
 304                 clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 305             }
 306         }
 307
 308         public void clickSubmitWithLocator( String locator )
 309         {
 310             clickLinkWithLocator( locator );
 311         }
 312
 313         public void clickSubmitWithLocator( String locator, boolean wait )
 314         {
 315             clickLinkWithLocator( locator, wait );
 316         }
 317
 318         public void clickImgWithAlt( String alt )
 319         {
 320             clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 321         }
 322
 323         public void clickLinkWithText( String text )
 324         {
 325             clickLinkWithText( text, true );
 326         }
 327
 328         public void clickLinkWithText( String text, boolean wait )
 329         {
 330             clickLinkWithLocator( "link=" + text, wait );
 331         }
 332
 333         public void clickLinkWithXPath( String xpath )
 334         {
 335             clickLinkWithXPath( xpath, true );
 336         }
 337
 338         public void clickLinkWithXPath( String xpath, boolean wait )
 339         {
 340             clickLinkWithLocator( "xpath=" + xpath, wait );
 341         }
 342
 343         public void clickLinkWithLocator( String locator )
 344         {
 345             clickLinkWithLocator( locator, true );
 346         }
 347
 348         public void clickLinkWithLocator( String locator, boolean wait )
 349         {
 350             assertElementPresent( locator );
 351             getSelenium().click( locator );
 352             if ( wait )
 353             {
 354                 waitPage();
 355             }
 356         }
 357
 358         public void setFieldValues( Map<String, String> fieldMap )
 359         {
 360             Map.Entry<String, String> entry;
 361
 362             for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 363             {
 364                 entry = entries.next();
 365
 366                 getSelenium().type( entry.getKey(), entry.getValue() );
 367             }
 368         }
 369
 370         public void setFieldValue( String fieldName, String value )
 371         {
 372             getSelenium().type( fieldName, value );
 373         }
 374
 375         public void checkField( String locator )
 376         {
 377             getSelenium().check( locator );
 378         }
 379
 380         public void uncheckField( String locator )
 381         {
 382             getSelenium().uncheck( locator );
 383         }
 384
 385         public boolean isChecked( String locator )
 386         {
 387             return getSelenium().isChecked( locator );
 388         }
 389
 390         public void assertIsChecked( String locator )
 391         {
 392             Assert.assertTrue( getSelenium().isChecked( locator ) );
 393         }
 394
 395         public void assertIsNotChecked( String locator )
 396         {
 397            Assert.assertFalse( getSelenium().isChecked( locator ) );
 398         }
 399
 400 }