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 com.thoughtworks.selenium.DefaultSelenium;
  23 import com.thoughtworks.selenium.Selenium;
  24 import org.apache.archiva.web.test.tools.AfterSeleniumFailure;
  25 import org.apache.commons.io.IOUtils;
  26 import org.junit.Assert;
  27
  28 import java.io.File;
  29 import java.io.IOException;
  30 import java.io.InputStream;
  31 import java.text.SimpleDateFormat;
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.Date;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Map.Entry;
  39 import java.util.Properties;
  40
  41 /**
  42  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  43  * @version $Id: AbstractSeleniumTestCase.java 761154 2009-04-02 03:31:19Z wsmoak $
  44  */
  45
  46 public abstract class AbstractSeleniumTest
  47 {
  48
  49     public static String baseUrl;
  50
  51     public static String maxWaitTimeInMs;
  52
  53     private static ThreadLocal<Selenium> selenium = new ThreadLocal<Selenium>();
  54
  55     public static Properties p;
  56
  57     private final static String PROPERTIES_SEPARATOR = "=";
  58
  59     public void open()
  60         throws Exception
  61     {
  62         p = new Properties();
  63         p.load( this.getClass().getClassLoader().getResourceAsStream( "test.properties" ) );
  64     }
  65
  66     /**
  67      * Initialize selenium
  68      */
  69     public void open( String baseUrl, String browser, String seleniumHost, int seleniumPort, String maxWaitTimeInMs )
  70         throws Exception
  71     {
  72         try
  73         {
  74             AbstractSeleniumTest.baseUrl = baseUrl;
  75             AbstractSeleniumTest.maxWaitTimeInMs = maxWaitTimeInMs;
  76
  77             if ( getSelenium() == null )
  78             {
  79                 DefaultSelenium s = new DefaultSelenium( seleniumHost, seleniumPort, browser, baseUrl );
  80
  81                 s.start();
  82                 s.setTimeout( maxWaitTimeInMs );
  83                 selenium.set( s );
  84             }
  85         }
  86         catch ( Exception e )
  87         {
  88             // yes
  89             System.out.print( e.getMessage() );
  90             e.printStackTrace();
  91         }
  92     }
  93
  94     public static Selenium getSelenium()
  95     {
  96         return selenium == null ? null : selenium.get();
  97     }
  98
  99     protected String getProperty( String key )
 100     {
 101         return p.getProperty( key );
 102     }
 103
 104     protected String getEscapeProperty( String key )
 105     {
 106         InputStream input = this.getClass().getClassLoader().getResourceAsStream( "test.properties" );
 107         String value = null;
 108         List<String> lines;
 109         try
 110         {
 111             lines = IOUtils.readLines( input );
 112         }
 113         catch ( IOException e )
 114         {
 115             lines = new ArrayList<String>();
 116         }
 117         for ( String l : lines )
 118         {
 119             if ( l != null && l.startsWith( key ) )
 120             {
 121                 int indexSeparator = l.indexOf( PROPERTIES_SEPARATOR );
 122                 value = l.substring( indexSeparator + 1 ).trim();
 123                 break;
 124             }
 125         }
 126         return value;
 127     }
 128
 129     /**
 130      * Close selenium session.
 131      */
 132     public void close()
 133         throws Exception
 134     {
 135         if ( getSelenium() != null )
 136         {
 137             getSelenium().stop();
 138             selenium.set( null );
 139         }
 140     }
 141
 142     // *******************************************************
 143     // Auxiliar methods. This method help us and simplify test.
 144     // *******************************************************
 145
 146     public void assertFieldValue( String fieldValue, String fieldName )
 147     {
 148         assertElementPresent( fieldName );
 149         Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
 150     }
 151
 152     public void assertPage( String title )
 153     {
 154         Assert.assertEquals( getTitle(), title );
 155     }
 156
 157     public String getTitle()
 158     {
 159         // Collapse spaces
 160         return getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
 161     }
 162
 163     public String getHtmlContent()
 164     {
 165         return getSelenium().getHtmlSource();
 166     }
 167
 168     public String getText( String locator )
 169     {
 170         return getSelenium().getText( locator );
 171     }
 172
 173     public void assertTextPresent( String text )
 174     {
 175         Assert.assertTrue( "'" + text + "' isn't present.", getSelenium().isTextPresent( text ) );
 176     }
 177
 178     /**
 179      * one of text args must be in the page so use en and fr text (olamy use en locale :-) )
 180      *
 181      * @param texts
 182      */
 183     public void assertTextPresent( String... texts )
 184     {
 185         boolean present = false;
 186         StringBuilder sb = new StringBuilder();
 187         for ( String text : texts )
 188         {
 189             present = present || getSelenium().isTextPresent( text );
 190             sb.append( " " + text + " " );
 191         }
 192         Assert.assertTrue( "'one of the following test " + sb.toString() + "' isn't present.", present );
 193     }
 194
 195     public void assertTextNotPresent( String text )
 196     {
 197         Assert.assertFalse( "'" + text + "' is present.", getSelenium().isTextPresent( text ) );
 198     }
 199
 200     public void assertElementPresent( String elementLocator )
 201     {
 202         Assert.assertTrue( "'" + elementLocator + "' isn't present.", isElementPresent( elementLocator ) );
 203     }
 204
 205     public void assertElementNotPresent( String elementLocator )
 206     {
 207         Assert.assertFalse( "'" + elementLocator + "' is present.", isElementPresent( elementLocator ) );
 208     }
 209
 210     public void assertLinkPresent( String text )
 211     {
 212         Assert.assertTrue( "The link '" + text + "' isn't present.", isElementPresent( "link=" + text ) );
 213     }
 214
 215     public void assertLinkNotPresent( String text )
 216     {
 217         Assert.assertFalse( "The link('" + text + "' is present.", isElementPresent( "link=" + text ) );
 218     }
 219
 220     public void assertLinkNotVisible( String text )
 221     {
 222         Assert.assertFalse( "The link('" + text + "' is visible.", isElementVisible( "link=" + text ) );
 223     }
 224
 225     public void assertLinkVisible( String text )
 226     {
 227         Assert.assertTrue( "The link('" + text + "' is not visible.", isElementVisible( "link=" + text ) );
 228     }
 229
 230     public void assertImgWithAlt( String alt )
 231     {
 232         assertElementPresent( "/¯img[@alt='" + alt + "']" );
 233     }
 234
 235     public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
 236     {
 237         String locator = "//tr[" + row + "]/td[" + column + "]/";
 238         locator += isALink ? "a/" : "";
 239         locator += "img[@alt='" + alt + "']";
 240
 241         assertElementPresent( locator );
 242     }
 243
 244     public void assertImgWithAltNotPresent( String alt )
 245     {
 246         assertElementNotPresent( "/¯img[@alt='" + alt + "']" );
 247     }
 248
 249     public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
 250     {
 251         Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
 252     }
 253
 254     public boolean isTextPresent( String text )
 255     {
 256         return getSelenium().isTextPresent( text );
 257     }
 258
 259     public boolean isLinkPresent( String text )
 260     {
 261         return isElementPresent( "link=" + text );
 262     }
 263
 264     public boolean isElementPresent( String locator )
 265     {
 266         return getSelenium().isElementPresent( locator );
 267     }
 268
 269     public boolean isElementVisible( String locator )
 270     {
 271         return getSelenium().isVisible( locator );
 272     }
 273
 274
 275     public void waitPage()
 276     {
 277         // TODO define a smaller maxWaitTimeJsInMs for wait javascript response for browser side validation
 278         //getSelenium().w .wait( Long.parseLong( maxWaitTimeInMs ) );
 279         //getSelenium().waitForPageToLoad( maxWaitTimeInMs );
 280         // http://jira.openqa.org/browse/SRC-302
 281         // those hack looks to break some tests :-(
 282         // getSelenium().waitForCondition( "selenium.isElementPresent('document.body');", maxWaitTimeInMs );
 283         //getSelenium().waitForCondition( "selenium.isElementPresent('footer');", maxWaitTimeInMs );
 284         //getSelenium().waitForCondition( "selenium.browserbot.getCurrentWindow().document.getElementById('footer')",
 285         //                                maxWaitTimeInMs );
 286         // so the only hack is to not use a too small wait time
 287
 288         try
 289         {
 290             Thread.sleep( Long.parseLong( maxWaitTimeInMs ) );
 291         }
 292         catch ( InterruptedException e )
 293         {
 294             throw new RuntimeException( "issue on Thread.sleep : " + e.getMessage(), e );
 295         }
 296     }
 297
 298     public String getFieldValue( String fieldName )
 299     {
 300         return getSelenium().getValue( fieldName );
 301     }
 302
 303     public String getCellValueFromTable( String tableElement, int row, int column )
 304     {
 305         return getSelenium().getTable( tableElement + "." + row + "." + column );
 306     }
 307
 308     public void selectValue( String locator, String value )
 309     {
 310         getSelenium().select( locator, "label=" + value );
 311     }
 312
 313
 314     public void assertOptionPresent( String selectField, String[] options )
 315     {
 316         assertElementPresent( selectField );
 317         String[] optionsPresent = getSelenium().getSelectOptions( selectField );
 318         List<String> expected = Arrays.asList( options );
 319         List<String> present = Arrays.asList( optionsPresent );
 320         Assert.assertTrue( "Options expected are not included in present options", present.containsAll( expected ) );
 321     }
 322
 323     public void assertSelectedValue( String value, String fieldName )
 324     {
 325         assertElementPresent( fieldName );
 326         String optionsPresent = getSelenium().getSelectedLabel( value );
 327         Assert.assertEquals( optionsPresent, value );
 328     }
 329
 330     public void submit()
 331     {
 332         clickLinkWithXPath( "//input[@type='submit']" );
 333     }
 334
 335     public void assertButtonWithValuePresent( String text )
 336     {
 337         Assert.assertTrue( "'" + text + "' button isn't present", isButtonWithValuePresent( text ) );
 338     }
 339
 340     public void assertButtonWithIdPresent( String id )
 341     {
 342         Assert.assertTrue( "'Button with id =" + id + "' isn't present", isButtonWithIdPresent( id ) );
 343     }
 344
 345     public void assertButtonWithValueNotPresent( String text )
 346     {
 347         Assert.assertFalse( "'" + text + "' button is present", isButtonWithValuePresent( text ) );
 348     }
 349
 350     public boolean isButtonWithValuePresent( String text )
 351     {
 352         return isElementPresent( "//button[@value='" + text + "']" ) || isElementPresent(
 353             "//input[@value='" + text + "']" );
 354     }
 355
 356     public boolean isButtonWithIdPresent( String text )
 357     {
 358         return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
 359     }
 360
 361     public void clickButtonWithName( String text, boolean wait )
 362     {
 363         clickLinkWithXPath( "//input[@name='" + text + "']", wait );
 364     }
 365
 366     public void clickButtonWithValue( String text )
 367     {
 368         clickButtonWithValue( text, true );
 369     }
 370
 371     public void clickButtonWithValue( String text, boolean wait )
 372     {
 373         assertButtonWithValuePresent( text );
 374
 375         if ( isElementPresent( "//button[@value='" + text + "']" ) )
 376         {
 377             clickLinkWithXPath( "//button[@value='" + text + "']", wait );
 378         }
 379         else
 380         {
 381             clickLinkWithXPath( "//input[@value='" + text + "']", wait );
 382         }
 383     }
 384
 385     public void clickSubmitWithLocator( String locator )
 386     {
 387         clickLinkWithLocator( locator );
 388     }
 389
 390     public void clickSubmitWithLocator( String locator, boolean wait )
 391     {
 392         clickLinkWithLocator( locator, wait );
 393     }
 394
 395     public void clickImgWithAlt( String alt )
 396     {
 397         clickLinkWithLocator( "//img[@alt='" + alt + "']" );
 398     }
 399
 400     public void clickLinkWithText( String text )
 401     {
 402         clickLinkWithText( text, true );
 403     }
 404
 405     public void clickLinkWithText( String text, boolean wait )
 406     {
 407         clickLinkWithLocator( "link=" + text, wait );
 408     }
 409
 410     public void clickLinkWithXPath( String xpath )
 411     {
 412         clickLinkWithXPath( xpath, true );
 413     }
 414
 415     public void clickLinkWithXPath( String xpath, boolean wait )
 416     {
 417         clickLinkWithLocator( "xpath=" + xpath, wait );
 418     }
 419
 420     public void clickLinkWithLocator( String locator )
 421     {
 422         clickLinkWithLocator( locator, true );
 423     }
 424
 425     public void clickLinkWithLocator( String locator, boolean wait )
 426     {
 427         assertElementPresent( locator );
 428         getSelenium().click( locator );
 429         if ( wait )
 430         {
 431             waitPage();
 432         }
 433     }
 434
 435     public void clickButtonWithLocator( String locator )
 436     {
 437         clickButtonWithLocator( locator, true );
 438     }
 439
 440     public void clickButtonWithLocator( String locator, boolean wait )
 441     {
 442         assertElementPresent( locator );
 443         getSelenium().click( locator );
 444         if ( wait )
 445         {
 446             waitPage();
 447         }
 448     }
 449
 450     public void setFieldValues( Map<String, String> fieldMap )
 451     {
 452         Map.Entry<String, String> entry;
 453
 454         for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
 455         {
 456             entry = entries.next();
 457
 458             getSelenium().type( entry.getKey(), entry.getValue() );
 459         }
 460     }
 461
 462     public void setFieldValue( String fieldName, String value )
 463     {
 464         getSelenium().type( fieldName, value );
 465     }
 466
 467     public void checkField( String locator )
 468     {
 469         getSelenium().check( locator );
 470     }
 471
 472     public void uncheckField( String locator )
 473     {
 474         getSelenium().uncheck( locator );
 475     }
 476
 477     public boolean isChecked( String locator )
 478     {
 479         return getSelenium().isChecked( locator );
 480     }
 481
 482     public void assertIsChecked( String locator )
 483     {
 484         Assert.assertTrue( getSelenium().isChecked( locator ) );
 485     }
 486
 487     public void assertIsNotChecked( String locator )
 488     {
 489         Assert.assertFalse( getSelenium().isChecked( locator ) );
 490     }
 491
 492     public void assertXpathCount( String locator, int expectedCount )
 493     {
 494         int count = getSelenium().getXpathCount( locator ).intValue();
 495         Assert.assertEquals( count, expectedCount );
 496     }
 497
 498     public void assertElementValue( String locator, String expectedValue )
 499     {
 500         Assert.assertEquals( getSelenium().getValue( locator ), expectedValue );
 501     }
 502
 503     @AfterSeleniumFailure
 504     public void captureScreenShotOnFailure( Throwable failure )
 505     {
 506         SimpleDateFormat sdf = new SimpleDateFormat( "yyyy.MM.dd-HH_mm_ss" );
 507         String time = sdf.format( new Date() );
 508         File targetPath = new File( "target", "screenshots" );
 509         String cName = this.getClass().getName();
 510
 511         String methodName = "";
 512         int lineNumber = 0;
 513
 514         for ( StackTraceElement stackTrace : failure.getStackTrace() )
 515         {
 516             if ( stackTrace.getClassName().equals( this.getClass().getName() ) )
 517             {
 518                 methodName = stackTrace.getMethodName();
 519                 lineNumber = stackTrace.getLineNumber();
 520                 break;
 521             }
 522         }
 523
 524         String className = cName.substring( cName.lastIndexOf( '.' ) + 1 );
 525         targetPath.mkdirs();
 526         Selenium selenium = AbstractSeleniumTest.getSelenium();
 527         String fileBaseName = methodName + "_" + className + ".java_" + lineNumber + "-" + time;
 528
 529         selenium.windowMaximize();
 530
 531         File fileName = new File( targetPath, fileBaseName + ".png" );
 532         selenium.captureEntirePageScreenshot( fileName.getAbsolutePath(), "background=#FFFFFF" );
 533
 534     }
 535
 536 }