package org.apache.archiva.web.test.parent;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.Selenium;
import org.apache.archiva.web.test.tools.ArchivaSeleniumExecutionRule;
import org.junit.Assert;
import org.junit.Rule;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import org.apache.commons.io.FileUtils;
/**
* @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
*
*/
public abstract class AbstractSeleniumTest
{
@Rule
public ArchivaSeleniumExecutionRule archivaSeleniumExecutionRule = new ArchivaSeleniumExecutionRule();
public String browser = System.getProperty( "browser" );
public String baseUrl =
"http://localhost:" + System.getProperty( "tomcat.maven.http.port" ) + "/archiva/index.html?request_lang=en";
public int maxWaitTimeInMs = Integer.getInteger( "maxWaitTimeInMs" );
public String seleniumHost = System.getProperty( "seleniumHost", "localhost" );
public int seleniumPort = Integer.getInteger( "seleniumPort", 4444 );
private Selenium selenium = null;
public Properties p;
/**
* this method is called by the Rule before executing a test
*
* @throws Exception
*/
public void open()
throws Exception
{
p = new Properties();
p.load( this.getClass().getClassLoader().getResourceAsStream( "test.properties" ) );
Properties tomcatPortProperties = new Properties();
tomcatPortProperties.load(
new FileInputStream( new File( System.getProperty( "tomcat.propertiesPortFilePath" ) ) ) );
int tomcatPort = Integer.parseInt( tomcatPortProperties.getProperty( "tomcat.maven.http.port" ) );
baseUrl = "http://localhost:" + tomcatPort + "/archiva/index.html?request_lang=en";
open( baseUrl, browser, seleniumHost, seleniumPort, maxWaitTimeInMs );
archivaSeleniumExecutionRule.selenium = selenium;
assertAdminCreated();
}
/**
* this method is called by the Rule after executing a tests
*/
public void close()
{
if ( getSelenium() != null )
{
getSelenium().stop();
}
}
/**
* Initialize selenium
*/
public void open( String baseUrl, String browser, String seleniumHost, int seleniumPort, int maxWaitTimeInMs )
throws Exception
{
try
{
if ( getSelenium() == null )
{
selenium = new DefaultSelenium( seleniumHost, seleniumPort, browser, baseUrl );
selenium.start();
selenium.setTimeout( Integer.toString( maxWaitTimeInMs ) );
}
}
catch ( Exception e )
{
// yes
System.out.print( e.getMessage() );
e.printStackTrace();
}
}
public void assertAdminCreated()
throws Exception
{
initializeArchiva( baseUrl, browser, maxWaitTimeInMs, seleniumHost, seleniumPort );
}
public void initializeArchiva( String baseUrl, String browser, int maxWaitTimeInMs, String seleniumHost,
int seleniumPort )
throws Exception
{
open( baseUrl, browser, seleniumHost, seleniumPort, maxWaitTimeInMs );
getSelenium().open( baseUrl );
waitPage();
// if not admin user created create one
if ( isElementVisible( "create-admin-link" ) )
{
Assert.assertFalse( getSelenium().isVisible( "login-link-a" ) );
Assert.assertFalse( getSelenium().isVisible( "register-link-a" ) );
// skygo need to set to true for passing is that work as expected ?
clickLinkWithLocator( "create-admin-link-a", true );
assertCreateAdmin();
String fullname = getProperty( "ADMIN_FULLNAME" );
String username = getAdminUsername();
String mail = getProperty( "ADMIN_EMAIL" );
String password = getProperty( "ADMIN_PASSWORD" );
submitAdminData( fullname, mail, password );
assertUserLoggedIn( username );
clickLinkWithLocator( "logout-link-a" );
}
else
{
Assert.assertTrue( getSelenium().isVisible( "login-link-a" ) );
Assert.assertTrue( getSelenium().isVisible( "register-link-a" ) );
login( getAdminUsername(), getAdminPassword() );
}
}
public Selenium getSelenium()
{
return selenium;
}
protected String getProperty( String key )
{
return p.getProperty( key );
}
public String getAdminUsername()
{
String adminUsername = getProperty( "ADMIN_USERNAME" );
return adminUsername;
}
public String getAdminPassword()
{
String adminPassword = getProperty( "ADMIN_PASSWORD" );
return adminPassword;
}
public void submitAdminData( String fullname, String email, String password )
{
setFieldValue( "fullname", fullname );
setFieldValue( "email", email );
setFieldValue( "password", password );
setFieldValue( "confirmPassword", password );
clickButtonWithLocator( "user-create-form-register-button" );
}
public void login( String username, String password )
{
login( username, password, true, "Login Page" );
}
public void login( String username, String password, boolean valid, String assertReturnPage )
{
if ( isElementVisible( "login-link-a" ) )//isElementPresent( "loginLink" ) )
{
goToLoginPage();
submitLoginPage( username, password, false, valid, assertReturnPage );
}
if ( valid )
{
assertUserLoggedIn( username );
}
}
// Go to Login Page
public void goToLoginPage()
{
getSelenium().open( baseUrl );
waitPage();
// are we already logged in ?
if ( isElementVisible( "logout-link" ) ) //isElementPresent( "logoutLink" ) )
{
// so logout
clickLinkWithLocator( "logout-link-a", false );
clickLinkWithLocator( "login-link-a" );
}
else if ( isElementVisible( "login-link-a" ) )
{
clickLinkWithLocator( "login-link-a" );
}
assertLoginModal();
}
public void assertLoginModal()
{
assertElementPresent( "user-login-form" );
Assert.assertTrue( isElementVisible( "register-link" ) );
assertElementPresent( "user-login-form-username" );
assertElementPresent( "user-login-form-password" );
assertButtonWithIdPresent( "modal-login-ok" );
}
public void submitLoginPage( String username, String password )
{
submitLoginPage( username, password, false, true, "Login Page" );
}
public void submitLoginPage( String username, String password, boolean validUsernamePassword )
{
submitLoginPage( username, password, false, validUsernamePassword, "Login Page" );
}
public void submitLoginPage( String username, String password, boolean rememberMe, boolean validUsernamePassword,
String assertReturnPage )
{
clickLinkWithLocator( "login-link-a", false );
setFieldValue( "user-login-form-username", username );
setFieldValue( "user-login-form-password", password );
/*
if ( rememberMe )
{
checkField( "rememberMe" );
}*/
clickButtonWithLocator( "modal-login-ok" );
if ( validUsernamePassword )
{
assertUserLoggedIn( username );
}
/*
else
{
if ( "Login Page".equals( assertReturnPage ) )
{
assertLoginPage();
}
else
{
assertPage( assertReturnPage );
}
}*/
}
// *******************************************************
// Auxiliar methods. This method help us and simplify test.
// *******************************************************
protected void assertUserLoggedIn( String username )
{
Assert.assertFalse( isElementVisible( "login-link" ) );
Assert.assertTrue( isElementVisible( "logout-link" ) );
Assert.assertFalse( isElementVisible( "register-link" ) );
Assert.assertFalse( isElementVisible( "create-admin-link" ) );
}
public void assertCreateAdmin()
{
assertElementPresent( "user-create" );
assertFieldValue( "admin", "username" );
assertElementPresent( "fullname" );
assertElementPresent( "password" );
assertElementPresent( "confirmPassword" );
assertElementPresent( "email" );
}
public void assertFieldValue( String fieldValue, String fieldName )
{
assertElementPresent( fieldName );
Assert.assertEquals( fieldValue, getSelenium().getValue( fieldName ) );
}
public void assertPage( String title )
{
Assert.assertEquals( getTitle(), title );
}
public String getTitle()
{
// Collapse spaces
return getSelenium().getTitle().replaceAll( "[ \n\r]+", " " );
}
public String getHtmlContent()
{
return getSelenium().getHtmlSource();
}
public String getText( String locator )
{
return getSelenium().getText( locator );
}
public void assertTextPresent( String text )
{
Assert.assertTrue( "'" + text + "' isn't present.", getSelenium().isTextPresent( text ) );
}
/**
* one of text args must be in the page so use en and fr text (olamy use en locale :-) )
*
* @param texts
*/
public void assertTextPresent( String... texts )
{
boolean present = false;
StringBuilder sb = new StringBuilder();
for ( String text : texts )
{
present = present || getSelenium().isTextPresent( text );
sb.append( " " + text + " " );
}
Assert.assertTrue( "'one of the following test " + sb.toString() + "' isn't present.", present );
}
public void assertTextNotPresent( String text )
{
Assert.assertFalse( "'" + text + "' is present.", getSelenium().isTextPresent( text ) );
}
public void assertElementPresent( String elementLocator )
{
Assert.assertTrue( "'" + elementLocator + "' isn't present.", isElementPresent( elementLocator ) );
}
public void assertElementNotPresent( String elementLocator )
{
Assert.assertFalse( "'" + elementLocator + "' is present.", isElementPresent( elementLocator ) );
}
public void assertLinkPresent( String text )
{
Assert.assertTrue( "The link '" + text + "' isn't present.", isElementPresent( "link=" + text ) );
}
public void assertLinkNotPresent( String text )
{
Assert.assertFalse( "The link('" + text + "' is present.", isElementPresent( "link=" + text ) );
}
public void assertLinkNotVisible( String text )
{
Assert.assertFalse( "The link('" + text + "' is visible.", isElementVisible( "link=" + text ) );
}
public void assertLinkVisible( String text )
{
Assert.assertTrue( "The link('" + text + "' is not visible.", isElementVisible( "link=" + text ) );
}
public void assertImgWithAlt( String alt )
{
assertElementPresent( "/¯img[@alt='" + alt + "']" );
}
public void assertImgWithAltAtRowCol( boolean isALink, String alt, int row, int column )
{
String locator = "//tr[" + row + "]/td[" + column + "]/";
locator += isALink ? "a/" : "";
locator += "img[@alt='" + alt + "']";
assertElementPresent( locator );
}
public void assertImgWithAltNotPresent( String alt )
{
assertElementNotPresent( "/¯img[@alt='" + alt + "']" );
}
public void assertCellValueFromTable( String expected, String tableElement, int row, int column )
{
Assert.assertEquals( expected, getCellValueFromTable( tableElement, row, column ) );
}
public boolean isTextPresent( String text )
{
return getSelenium().isTextPresent( text );
}
public boolean isLinkPresent( String text )
{
return isElementPresent( "link=" + text );
}
public boolean isElementPresent( String locator )
{
return getSelenium().isElementPresent( locator );
}
public boolean isElementVisible( String locator )
{
return getSelenium().isVisible( locator );
}
public void waitPage()
{
// TODO define a smaller maxWaitTimeJsInMs for wait javascript response for browser side validation
//getSelenium().w .wait( Long.parseLong( maxWaitTimeInMs ) );
//getSelenium().waitForPageToLoad( maxWaitTimeInMs );
// http://jira.openqa.org/browse/SRC-302
// those hack looks to break some tests :-(
// getSelenium().waitForCondition( "selenium.isElementPresent('document.body');", maxWaitTimeInMs );
//getSelenium().waitForCondition( "selenium.isElementPresent('footer');", maxWaitTimeInMs );
//getSelenium().waitForCondition( "selenium.browserbot.getCurrentWindow().document.getElementById('footer')",
// maxWaitTimeInMs );
// so the only hack is to not use a too small wait time
try
{
Thread.sleep( maxWaitTimeInMs );
}
catch ( InterruptedException e )
{
throw new RuntimeException( "issue on Thread.sleep : " + e.getMessage(), e );
}
}
public String getFieldValue( String fieldName )
{
return getSelenium().getValue( fieldName );
}
public String getCellValueFromTable( String tableElement, int row, int column )
{
return getSelenium().getTable( tableElement + "." + row + "." + column );
}
public void selectValue( String locator, String value )
{
getSelenium().select( locator, "label=" + value );
}
public void assertOptionPresent( String selectField, String[] options )
{
assertElementPresent( selectField );
String[] optionsPresent = getSelenium().getSelectOptions( selectField );
List<String> expected = Arrays.asList( options );
List<String> present = Arrays.asList( optionsPresent );
Assert.assertTrue( "Options expected are not included in present options", present.containsAll( expected ) );
}
public void assertSelectedValue( String value, String fieldName )
{
assertElementPresent( fieldName );
String optionsPresent = getSelenium().getSelectedLabel( value );
Assert.assertEquals( optionsPresent, value );
}
public void submit()
{
clickLinkWithXPath( "//input[@type='submit']" );
}
public void assertButtonWithValuePresent( String text )
{
Assert.assertTrue( "'" + text + "' button isn't present", isButtonWithValuePresent( text ) );
}
public void assertButtonWithIdPresent( String id )
{
Assert.assertTrue( "'Button with id =" + id + "' isn't present", isButtonWithIdPresent( id ) );
}
public void assertButtonWithValueNotPresent( String text )
{
Assert.assertFalse( "'" + text + "' button is present", isButtonWithValuePresent( text ) );
}
public boolean isButtonWithValuePresent( String text )
{
return isElementPresent( "//button[@value='" + text + "']" ) || isElementPresent(
"//input[@value='" + text + "']" );
}
public boolean isButtonWithIdPresent( String text )
{
return isElementPresent( "//button[@id='" + text + "']" ) || isElementPresent( "//input[@id='" + text + "']" );
}
public void clickButtonWithName( String text, boolean wait )
{
clickLinkWithXPath( "//input[@name='" + text + "']", wait );
}
public void clickButtonWithValue( String text )
{
clickButtonWithValue( text, true );
}
public void clickButtonWithValue( String text, boolean wait )
{
assertButtonWithValuePresent( text );
if ( isElementPresent( "//button[@value='" + text + "']" ) )
{
clickLinkWithXPath( "//button[@value='" + text + "']", wait );
}
else
{
clickLinkWithXPath( "//input[@value='" + text + "']", wait );
}
}
public void clickSubmitWithLocator( String locator )
{
clickLinkWithLocator( locator );
}
public void clickSubmitWithLocator( String locator, boolean wait )
{
clickLinkWithLocator( locator, wait );
}
public void clickImgWithAlt( String alt )
{
clickLinkWithLocator( "//img[@alt='" + alt + "']" );
}
public void clickLinkWithText( String text )
{
clickLinkWithText( text, true );
}
public void clickLinkWithText( String text, boolean wait )
{
clickLinkWithLocator( "link=" + text, wait );
}
public void clickLinkWithXPath( String xpath )
{
clickLinkWithXPath( xpath, true );
}
public void clickLinkWithXPath( String xpath, boolean wait )
{
clickLinkWithLocator( "xpath=" + xpath, wait );
}
public void clickLinkWithLocator( String locator )
{
clickLinkWithLocator( locator, true );
}
public void clickLinkWithLocator( String locator, boolean wait )
{
assertElementPresent( locator );
getSelenium().click( locator );
if ( wait )
{
waitPage();
}
}
public void clickButtonWithLocator( String locator )
{
clickButtonWithLocator( locator, true );
}
public void clickButtonWithLocator( String locator, boolean wait )
{
assertElementPresent( locator );
getSelenium().click( locator );
if ( wait )
{
waitPage();
}
}
public void setFieldValues( Map<String, String> fieldMap )
{
Map.Entry<String, String> entry;
for ( Iterator<Entry<String, String>> entries = fieldMap.entrySet().iterator(); entries.hasNext(); )
{
entry = entries.next();
getSelenium().type( entry.getKey(), entry.getValue() );
}
}
public void setFieldValue( String fieldName, String value )
{
getSelenium().type( fieldName, value );
}
public void checkField( String locator )
{
getSelenium().check( locator );
}
public void uncheckField( String locator )
{
getSelenium().uncheck( locator );
}
public boolean isChecked( String locator )
{
return getSelenium().isChecked( locator );
}
public void assertIsChecked( String locator )
{
Assert.assertTrue( getSelenium().isChecked( locator ) );
}
public void assertIsNotChecked( String locator )
{
Assert.assertFalse( getSelenium().isChecked( locator ) );
}
public void assertXpathCount( String locator, int expectedCount )
{
int count = getSelenium().getXpathCount( locator ).intValue();
Assert.assertEquals( count, expectedCount );
}
public void assertElementValue( String locator, String expectedValue )
{
Assert.assertEquals( getSelenium().getValue( locator ), expectedValue );
}
public String captureScreenShotOnFailure( Throwable failure, String methodName, String className )
{
SimpleDateFormat sdf = new SimpleDateFormat( "yyyy.MM.dd-HH_mm_ss" );
String time = sdf.format( new Date() );
File targetPath = new File( "target", "screenshots" );
int lineNumber = 0;
for ( StackTraceElement stackTrace : failure.getStackTrace() )
{
if ( stackTrace.getClassName().equals( this.getClass().getName() ) )
{
lineNumber = stackTrace.getLineNumber();
break;
}
}
targetPath.mkdirs();
Selenium selenium = getSelenium();
String fileBaseName = methodName + "_" + className + ".java_" + lineNumber + "-" + time;
selenium.windowMaximize();
try
{
// save html to have a minimum feedback if jenkins firefox not up
File fileNameHTML = new File( new File( "target", "errorshtmlsnap" ) , fileBaseName + ".html" );
FileUtils.writeStringToFile( fileNameHTML, selenium.getHtmlSource() );
}
catch ( IOException e )
{
System.out.print( e.getMessage() );
e.printStackTrace();
}
File fileName = new File( targetPath, fileBaseName + ".png" );
selenium.captureEntirePageScreenshot( fileName.getAbsolutePath(), "background=#FFFFFF" );
return fileName.getAbsolutePath();
}
}