|
|
Glassfish example source code file (BaseSeleniumTestClass.java)
This example Glassfish source code file (BaseSeleniumTestClass.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.
The Glassfish BaseSeleniumTestClass.java source code
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package org.glassfish.admingui.devtests;
import com.thoughtworks.selenium.Selenium;
import com.thoughtworks.selenium.SeleniumException;
import org.junit.*;
import org.openqa.selenium.*;
import java.io.*;
import java.math.BigInteger;
import java.net.URL;
import java.net.URLConnection;
import java.security.SecureRandom;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openqa.selenium.support.ui.ExpectedCondition;
public class BaseSeleniumTestClass {
public static final String CURRENT_WINDOW = "selenium.browserbot.getCurrentWindow()";
public static final int TIMEOUT_CALLBACK_LOOP = 1000;
public static final String TRIGGER_NEW_VALUES_SAVED = "New values successfully saved.";
public static final String TRIGGER_COMMON_TASKS = "Other Tasks";
public static final String TRIGGER_REGISTRATION_PAGE = "Receive patch information and bug updates, screencasts and tutorials, support and training offerings, and more";
public static final String TRIGGER_ERROR_OCCURED = "An error has occurred";
public static final boolean DEBUG = Boolean.parseBoolean(SeleniumHelper.getParameter("debug", "false"));
@Rule
public SpecificTestRule specificTestRule = new SpecificTestRule();
protected static final int TIMEOUT = 90;
protected static final int BUTTON_TIMEOUT = 750;
protected static final Logger logger = Logger.getLogger(BaseSeleniumTestClass.class.getName());
private static Selenium selenium;
private static WebDriver driver;
private static String currentTestClass = "";
private boolean processingLogin = false;
private static final String AJAX_INDICATOR = "ajaxIndicator";
private static final Map<String, String> bundles = new HashMap() {{
put("i18n", "org.glassfish.admingui.core.Strings"); // core
put("i18nUC", "org.glassfish.updatecenter.admingui.Strings"); // update center
put("i18n_corba", "org.glassfish.corba.admingui.Strings");
put("i18n_ejb", "org.glassfish.ejb.admingui.Strings");
put("i18n_ejbLite", "org.glassfish.ejb-lite.admingui.Strings");
put("i18n_jts" ,"org.glassfish.jts.admingui.Strings"); // JTS
put("i18n_web", "org.glassfish.web.admingui.Strings"); // WEB
put("common", "org.glassfish.common.admingui.Strings");
put("i18nc", "org.glassfish.common.admingui.Strings"); // common -- apparently we use both in the app :|
put("i18nce", "org.glassfish.admingui.community-theme.Strings");
put("i18ncs", "org.glassfish.cluster.admingui.Strings"); // cluster
put("i18njca", "org.glassfish.jca.admingui.Strings"); // JCA
put("i18njdbc", "org.glassfish.jdbc.admingui.Strings"); // JDBC
put("i18njmail", "org.glassfish.full.admingui.Strings");
put("i18njms", "org.glassfish.jms.admingui.Strings"); // JMS
put("theme", "org.glassfish.admingui.community-theme.Strings");
// TODO: These conflict with core and should probably be changed in the pages
//put("i18n", "org.glassfish.common.admingui.Strings");
//put("i18n", "org.glassfish.web.admingui.Strings");
//put("i18nc", "org.glassfish.web.admingui.Strings");
}};
private static final SeleniumHelper helper = SeleniumHelper.getInstance();
private ElementFinder elementFinder;
public BaseSeleniumTestClass() {
driver = helper.getDriver();
selenium = helper.getSeleniumInstance();
elementFinder = helper.getElementFinder();
if (Boolean.parseBoolean(SeleniumHelper.getParameter("slowDown", "false"))) {
driver.manage().timeouts().implicitlyWait(500, TimeUnit.MILLISECONDS);
}
}
@BeforeClass
public static void setUp() throws Exception {
if (!DEBUG) {
URL rotateLogUrl = new URL(helper.getBaseUrl() + "/management/domain/rotate-log");
URLConnection conn = rotateLogUrl.openConnection();
conn.setDoOutput(true);
OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
wr.write("");
wr.flush();
BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line = rd.readLine();
while (line != null) {
line = rd.readLine();
}
wr.close();
rd.close();
}
}
@AfterClass
public static void captureLog() {
try {
helper.releaseSeleniumInstance();
if (!currentTestClass.isEmpty() && !DEBUG) {
URL url = new URL("http://localhost:" + SeleniumHelper.getParameter("admin.port", "4848") + "/management/domain/view-log");
InputStream is = url.openStream();
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("target/surefire-reports/" + currentTestClass + "-server.log")));
BufferedReader in = new BufferedReader(new InputStreamReader(is));
String line = in.readLine();
while (line != null) {
out.write(line+System.getProperty("line.separator"));
line = in.readLine();
}
in.close();
out.close();
}
} catch (FileNotFoundException fnfe) {
//
} catch (Exception ex) {
Logger.getLogger(BaseSeleniumTestClass.class.getName()).log(Level.INFO, null, ex);
}
}
@Before
public void reset() {
selenium = helper.getSeleniumInstance();
currentTestClass = this.getClass().getName();
openAndWait("/", TRIGGER_COMMON_TASKS);
}
@After
public void afterTest() {
if (Boolean.parseBoolean(SeleniumHelper.getParameter("releaseAfter", "false"))) {
helper.releaseSeleniumInstance();
}
}
// *************************************************************************
// Wrappers for Selenium API
// *************************************************************************
/**
* Returns the current value for the specified field
* @see DefaultSelenium.getValue(String)
* @param elem
* @return
*/
public String getFieldValue(String elem) {
return selenium.getValue(elem);
}
/**
* Types the specified text into the requested element
* @param elem
* @param text
*/
public void setFieldValue(String elem, String text) {
selenium.type(elem, text);
}
/**
* Gets the text of an element.
* @see DefaultSelenium.getText(String)
* @param elem
* @return
*/
public String getText(String elem) {
return selenium.getText(elem);
}
/**
* Deelects (unchecks) the specified checkbox. After calling this method, the
* checkbox will be unchecked regardless of its initial state.
* @param cb
*/
public void markCheckbox(String cb) {
selenium.check(cb);
}
/**
* Selects (checks) the specified checkbox. After calling this method, the
* checkbox will be checked regardless of its initial state.
* @param cb
*/
public void clearCheckbox(String cb) {
selenium.uncheck(cb);
}
public void pressButton(String button) {
selenium.click(button);
}
/**
* Return the selected value of the specified select element
* @param elem
* @return
*/
public String getSelectedValue(String elem) {
return selenium.getSelectedValue(elem);
}
/**
* Returns true is the specified element is present on the page
* @param elem
* @return
*/
public boolean isElementPresent(String elem) {
return selenium.isElementPresent(elem);
}
/**
* Select the option requested in the given select element
* @param id
* @param label
*/
protected void selectDropdownOption(String id, String label) {
try {
label = resolveTriggerText(label);
selenium.select(id, "label="+label);
} catch (SeleniumException se) {
logger.log(Level.INFO, "An invalid option was requested. Here are the valid options:");
for (String option : selenium.getSelectOptions(id)) {
logger.log(Level.INFO, "\t{0}", option);
}
throw se;
}
}
/**
* Add a selection to the given select element
* @param elem
* @param label
*/
protected void addSelectSelection(String elem, String label) {
try {
label = resolveTriggerText(label);
selenium.addSelection(elem, "label="+label);
} catch (SeleniumException se) {
logger.info("An invalid option was requested. Here are the valid options:");
for (String option : selenium.getSelectOptions(elem)) {
logger.log(Level.INFO, "\t{0}", option);
}
throw se;
}
}
/**
* Returns true if the specified checkbox is selected
* @param elem
* @return
*/
protected boolean isChecked(String elem) {
return selenium.isChecked(elem);
}
protected void selectFile(String uploadElement, String archivePath) {
selenium.attachFile(uploadElement, archivePath);
}
protected boolean isAlertPresent() {
return selenium.isAlertPresent();
}
protected boolean isConfirmationPresent() {
return selenium.isConfirmationPresent();
}
protected String getAlertText() {
return selenium.getAlert();
}
protected void chooseOkOnNextConfirmation() {
selenium.chooseOkOnNextConfirmation();
}
protected String getConfirmation() {
String confirmation = null;
if (isConfirmationPresent()) {
confirmation = selenium.getConfirmation();
}
return confirmation;
}
protected void waitForPopUp(String windowId, String timeout) {
selenium.waitForPopUp(windowId, timeout);
}
protected String getSelectedLabel(String elem) {
return selenium.getSelectedLabel(elem);
}
protected void open(String url) {
selenium.open(url);
}
protected void submitForm(String formId) {
selenium.submit(formId);
}
// *************************************************************************
// Wrappers for Selenium API
// *************************************************************************
protected String generateRandomString() {
SecureRandom random = new SecureRandom();
// prepend a letter to insure valid JSF ID, which is causing failures in some areas
return "a" + new BigInteger(130, random).toString(16);
}
protected int generateRandomNumber() {
Random r = new Random();
return Math.abs(r.nextInt()) + 1;
}
protected int generateRandomNumber(int max) {
Random r = new Random();
return Math.abs(r.nextInt(max - 1)) + 1;
}
protected <T> T selectRandomItem(T... items) {
Random r = new Random();
return items[r.nextInt(items.length)];
}
protected int getTableRowCount(String id) {
String text = getText(id);
int count = Integer.parseInt(text.substring(text.indexOf("(") + 1, text.indexOf(")")));
return count;
}
protected void openAndWait(String url, String triggerText) {
openAndWait(url, triggerText, TIMEOUT);
}
protected void openAndWait(String url, String triggerText, int timeout) {
open(url);
// wait for 2 minutes, as that should be enough time to insure that the admin console app has been deployed by the server
waitForPageLoad(triggerText, timeout);
}
/**
* Click the specified element and wait for the specified trigger text on the resulting page, timing out TIMEOUT seconds.
*
* @param triggerText
*/
protected void clickAndWait(String id, String triggerText) {
clickAndWait(id, triggerText, TIMEOUT);
}
protected void clickAndWait(String id, String triggerText, int seconds) {
log ("Clicking on {0} \"{1}\"", id, triggerText);
insureElementIsVisible(id);
pressButton(id);
waitForPageLoad(triggerText, seconds);
}
protected void clickAndWait(String id, WaitForLoadCallBack callback) {
insureElementIsVisible(id);
pressButton(id);
waitForLoad(TIMEOUT, callback);
}
protected void clickAndWaitForElement(String clickId, final String elementId) {
pressButton(clickId);
waitForLoad(60, new WaitForLoadCallBack() {
@Override
public boolean executeTest() {
if (isElementPresent(elementId)) {
return true;
}
return false;
}
});
}
protected void clickAndWaitForButtonEnabled(String id) {
pressButton(id);
waitForButtonEnabled(id);
}
// Argh!
protected void sleep(int millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
// e.printStackTrace();
}
}
/**
* Cause the test to wait for the page to load. This will be used, for example, after an initial page load
* (selenium.open) or after an Ajaxy navigation request has been made.
*
* @param triggerText The text that should appear on the page when it has finished loading
* @param timeout How long to wait (in seconds)
*/
protected void waitForPageLoad(String triggerText, int timeout) {
waitForLoad(timeout, new PageLoadCallBack(triggerText, false));
}
protected void waitForPageLoad(final String triggerText, final boolean textShouldBeMissing) {
waitForPageLoad(triggerText, TIMEOUT, textShouldBeMissing);
}
protected void waitForPageLoad(final String triggerText, final int timeout, final boolean textShouldBeMissing) {
waitForLoad(timeout, new PageLoadCallBack(triggerText, textShouldBeMissing));
}
protected void waitForLoad(int timeoutInSeconds, WaitForLoadCallBack callback) {
for (int seconds = 0;; seconds++) {
if (seconds >= (timeoutInSeconds)) {
Assert.fail("The operation timed out waiting for the page to load.");
}
RenderedWebElement ajaxPanel = (RenderedWebElement)
elementFinder.findElement(By.id(AJAX_INDICATOR), TIMEOUT,
new ExpectedCondition<Boolean>() {
@Override
public Boolean apply(WebDriver driver) {
RenderedWebElement ajaxPanel = (RenderedWebElement) driver.findElement(By.id(AJAX_INDICATOR));
return !ajaxPanel.isDisplayed();
}
});
// if (!ajaxPanel.isDisplayed()) {
if (callback.executeTest()) {
break;
}
// }
sleep(TIMEOUT_CALLBACK_LOOP);
}
}
protected void handleLogin() {
processingLogin = true;
setFieldValue("j_username", "admin");
setFieldValue("j_password", "");
clickAndWait("loginButton", TRIGGER_COMMON_TASKS);
processingLogin = false;
}
protected void waitForButtonEnabled(String buttonId) {
// waitForCondition("document.getElementById('" + buttonId + "').disabled == false", BUTTON_TIMEOUT);
waitForLoad(BUTTON_TIMEOUT, new ButtonDisabledStateCallBack(buttonId, false));
}
protected void waitForButtonDisabled(String buttonId) {
String value = selenium.getEval(CURRENT_WINDOW + ".document.getElementById('" + buttonId + "').disabled");
// waitForCondition("document.getElementById('" + buttonId + "').disabled == true", BUTTON_TIMEOUT);
waitForLoad(BUTTON_TIMEOUT, new ButtonDisabledStateCallBack(buttonId, true));
}
protected void waitForCondition(String js, int timeOutInMillis) {
selenium.waitForCondition(CURRENT_WINDOW + "." + js, Integer.toString(timeOutInMillis));
}
protected void deleteRow(String buttonId, String tableId, String triggerText) {
deleteRow(buttonId, tableId, triggerText, "col0", "col1");
}
protected void deleteRow(final String buttonId, final String tableId, final String triggerText, final String selectColId, final String valueColId) {
rowActionWithConfirm(buttonId, tableId, triggerText, selectColId, valueColId);
waitForLoad(TIMEOUT, new DeleteRowCallBack(tableId, triggerText, valueColId));
// waitForPageLoad(triggerText, true);
}
protected void rowActionWithConfirm(String buttonId, String tableId, String triggerText) {
rowActionWithConfirm(buttonId, tableId, triggerText, "col0", "col1");
}
protected void rowActionWithConfirm(String buttonId, String tableId, String triggerText, String selectColId, String valueColId) {
// A defensive getConfirmation()
getConfirmation();
chooseOkOnNextConfirmation();
selectTableRowByValue(tableId, triggerText, selectColId, valueColId);
sleep(500); // argh!
waitForButtonEnabled(buttonId);
pressButton(buttonId);
getConfirmation();
sleep(500); // argh!
waitForButtonDisabled(buttonId);
}
/**
* This method will scan the all ths links for the link with the given text. We can't rely on a link's position
* in the table, as row order may vary (if, for example, a prior test run left data behind). If the link is not
* found, null is returned, so the calling code may need to check the return value prior to use.
*
* @param baseId
* @param value
* @return
*/
protected String getLinkIdByLinkText(String baseId, String value) {
WebElement link = elementFinder.findElement(By.linkText(value), TIMEOUT);
//driver.findElement(By.linkText(value));
return (link == null) ? null : (String)link.getAttribute("id");
/*
String[] links = selenium.getAllLinks();
for (String link : links) {
if (link.startsWith(baseId)) {
String linkText = selenium.getText(link);
if (value.equals(linkText)) {
return link;
}
}
}
return null;
*/
}
protected boolean isTextPresent(String text) {
return selenium.isTextPresent(resolveTriggerText(text));
}
protected void selectTableRowByValue(String tableId, String value) {
selectTableRowByValue(tableId, value, "col0", "col1");
}
protected void selectTableRowByValue(String tableId, String value, String selectColId, String valueColId) {
List<String> rows = getTableRowsByValue(tableId, value, valueColId);
for (String row : rows) {
// It seems this must be click for the JS to fire in the browser
final String id = row + ":" + selectColId + ":select";
selectTableRow(row, selectColId);
}
}
/**
* @See selectTableRowByValue(String tableId, String value, String selectColId, String valueColId);
* @param baseId
* @param value
* @return
*/
protected int selectTableRowsByValue(String baseId, String value) {
return selectTableRowsByValue(baseId, value, "col0", "col1");
}
/**
* For the given table, this method will select each row whose value in the specified column
* matched the value given, returning the number of rows selected.
*/
protected int selectTableRowsByValue(String tableId, String value, String selectColId, String valueColId) {
List<String> rows = getTableRowsByValue(tableId, value, valueColId);
if (!rows.isEmpty()) {
for (String row : rows) {
selectTableRow(row, selectColId);
}
}
return rows.size();
}
private void selectTableRow(String rowId, String colId) {
boolean rowHighlighted = false;
int iterations = 0;
this.log("Clicking on {0} in row {1} and making it sure it is highlighted", colId, rowId);
while (!rowHighlighted && (iterations <= 50)) {
selenium.click(rowId + ":" + colId + ":select");
markCheckbox(rowId + ":" + colId + ":select");
sleep(500);
String rowClass = selenium.getAttribute("identifier="+rowId+"@class");
rowHighlighted = ((rowClass != null) && (rowClass.contains("TblSelRow_sun4")));
iterations++;
}
if (iterations >= 50) {
throw new RuntimeException("Timed out wait for row in " + rowId + " to be selected.");
}
}
protected void deleteAllTableRows(String tableId) {
String deleteButtonId = tableId + ":topActionsGroup1:button1";
selectAllTableRows(tableId);
waitForButtonEnabled(deleteButtonId);
chooseOkOnNextConfirmation();
pressButton(deleteButtonId);
getConfirmation();
this.waitForButtonDisabled(deleteButtonId);
}
protected void selectAllTableRows(String tableId) {
int count = getTableRowCount(tableId);
for (int i = 0 ; i < count; i++) {
selenium.click(tableId+":rowGroup1:" + i +":col0:select");
markCheckbox(tableId+":rowGroup1:" + i +":col0:select");
}
}
// TODO: write javadocs for this
protected String getTableRowByValue(String tableId, String value, String valueColId) {
try {
int row = 0;
while (true) { // iterate over any rows
// Assume one row group for now and hope it doesn't bite us
String text = getText(tableId + ":rowGroup1:" + row + ":" + valueColId);
if (text.equals(value)) {
return tableId + ":rowGroup1:" + row + ":";
}
row++;
}
} catch (Exception e) {
Assert.fail("The specified row was not found: " + value);
return "";
}
}
protected List<String> getTableRowsByValue(String tableId, String value, String valueColId) {
List<String> rows = new ArrayList();
try {
int row = 0;
while (true) { // iterate over any rows
// Assume one row group for now and hope it doesn't bite us
String text = getText(tableId + ":rowGroup1:" + row + ":" + valueColId);
if (text.contains(value)) {
rows.add(tableId + ":rowGroup1:" + row);
}
row++;
}
} catch (Exception e) {
}
return rows;
}
// TODO: write javadocs for this
protected int getTableRowCountByValue(String tableId, String value, String valueColId, Boolean isLabel) {
int tableCount = getTableRowCount(tableId);
int selectedCount = 0;
try {
for (int i = 0; i < tableCount; i++) {
String text = "";
if (isLabel) {
text = getText(tableId + ":rowGroup1:" + i + ":" + valueColId);
} else {
text = getFieldValue(tableId + ":rowGroup1:" + i + ":" + valueColId);
}
if (text.equals(value)) {
selectedCount++;
}
}
} catch (Exception e) {
Assert.fail("The specified row was not found: " + value);
return 0;
}
return selectedCount;
}
protected int getTableRowCountByValue(String tableId, String value, String valueColId) {
return getTableRowCountByValue(tableId, value, valueColId, true);
}
protected List<String> getTableColumnValues(String tableId, String columnId) {
List<String> values = new ArrayList();
int tableCount = getTableRowCount(tableId);
try {
int row = 0;
while (true) { // iterate over any rows
// Assume one row group for now and hope it doesn't bite us
values.add(getText(tableId + ":rowGroup1:" + row + ":" + columnId));
row++;
}
} catch (Exception e) {
}
return values;
}
protected boolean tableContainsRow(String tableId, String columnId, String value) {
return getTableRowCountByValue(tableId, value, columnId) > 0;
}
protected int addTableRow(String tableId, String buttonId) {
return addTableRow(tableId, buttonId, "Additional Properties");
}
protected int addTableRow(String tableId, String buttonId, String countLabel) {
int count = getTableRowCount(tableId);
clickAndWait(buttonId, new AddTableRowCallBack(tableId, count));
return ++count;
}
protected void assertTableRowCount(String tableId, int count) {
Assert.assertEquals(count, getTableRowCount(tableId));
}
// Look at all those params. Maybe this isn't such a hot idea.
/**
* @param resourceName
* @param tableId
* @param enableButtonId
* @param statusID
* @param backToTableButtonId
* @param tableTriggerText
* @param editTriggerText
*/
protected void testEnableButton(String resourceName,
String tableId,
String enableButtonId,
String statusID,
String backToTableButtonId,
String tableTriggerText,
String editTriggerText,
String statusMsg) {
testEnableDisableButton(resourceName, tableId, enableButtonId, statusID, backToTableButtonId, tableTriggerText, editTriggerText, statusMsg);
}
protected void testDisableButton(String resourceName,
String tableId,
String disableButtonId,
String statusId,
String backToTableButtonId,
String tableTriggerText,
String editTriggerText,
String statusMsg) {
testEnableDisableButton(resourceName, tableId, disableButtonId, statusId, backToTableButtonId, tableTriggerText, editTriggerText, statusMsg);
}
private void testEnableDisableButton(String resourceName,
String tableId,
String enableButtonId,
String statusId,
String backToTableButtonId,
String tableTriggerText,
String editTriggerText,
String state) {
sleep(TIMEOUT_CALLBACK_LOOP); // yuck
selectTableRowByValue(tableId, resourceName);
waitForButtonEnabled(enableButtonId);
pressButton(enableButtonId);
waitForButtonDisabled(enableButtonId);
clickAndWait(getLinkIdByLinkText(tableId, resourceName), editTriggerText);
// TODO: this is an ugly, ugly hack and needs to be cleaned up
if(state.contains("Target")) {
Assert.assertEquals(state, getText(statusId));
} else {
if ("on".equals(state) || "off".equals(state)) {
Assert.assertEquals("on".equals(state), isChecked(statusId));
} else {
Assert.assertEquals(state, getFieldValue(statusId));
}
}
clickAndWait(backToTableButtonId, tableTriggerText);
}
protected void testEnableOrDisableTarget(String tableSelectMutlipleId,
String enableButtonId,
String generalTabId,
String targetTabId,
String statusId,
String generalTriggerText,
String targetTriggerText,
String state) {
pressButton(tableSelectMutlipleId);
waitForButtonEnabled(enableButtonId);
pressButton(enableButtonId);
waitForButtonDisabled(enableButtonId);
clickAndWait(generalTabId, generalTriggerText);
Assert.assertEquals(state, getText(statusId));
clickAndWait(targetTabId, targetTriggerText);
}
protected void testManageTargets(String resourcesLinkId,
String resourcesTableId,
String enableButtonId,
String disableButtonId,
String enableOrDisableTextFieldId,
String resGeneralTabId,
String resTargetTabId,
String resourcesTriggerText,
String resEditTriggerText,
String jndiName,
String instanceName) {
final String TRIGGER_EDIT_RESOURCE_TARGETS = "Resource Targets";
final String enableStatus = "Enabled on 2 of 2 Target(s)";
final String disableStatus = "Enabled on 0 of 2 Target(s)";
final String TRIGGER_MANAGE_TARGETS = "Manage Resource Targets";
final String DEFAULT_SERVER = "server";
reset();
clickAndWait(resourcesLinkId, resourcesTriggerText);
clickAndWait(getLinkIdByLinkText(resourcesTableId, jndiName), resEditTriggerText);
//Click on the target tab and verify whether the target is in the target table or not.
clickAndWait(resTargetTabId, TRIGGER_EDIT_RESOURCE_TARGETS);
Assert.assertTrue(isTextPresent(instanceName));
//Disable all targets
testEnableOrDisableTarget("propertyForm:targetTable:_tableActionsTop:_selectMultipleButton:_selectMultipleButton_image",
disableButtonId,
resGeneralTabId,
resTargetTabId,
enableOrDisableTextFieldId,
resEditTriggerText,
TRIGGER_EDIT_RESOURCE_TARGETS,
disableStatus);
//Enable all targets
testEnableOrDisableTarget("propertyForm:targetTable:_tableActionsTop:_selectMultipleButton:_selectMultipleButton_image",
enableButtonId,
resGeneralTabId,
resTargetTabId,
enableOrDisableTextFieldId,
resEditTriggerText,
TRIGGER_EDIT_RESOURCE_TARGETS,
enableStatus);
//Test the manage targets : Remove the server from targets.
clickAndWait("propertyForm:targetTable:topActionsGroup1:manageTargetButton", TRIGGER_MANAGE_TARGETS);
addSelectSelection("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove_selected", DEFAULT_SERVER);
pressButton("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove:commonAddRemove_removeButton");
clickAndWait("form:propertyContentPage:topButtons:saveButton", TRIGGER_NEW_VALUES_SAVED);
//Test the issue : 13280
//If server instance is not one of the target, edit resource was failing. Fixed that and added a test
clickAndWait(resourcesLinkId, resourcesTriggerText);
clickAndWait(getLinkIdByLinkText(resourcesTableId, jndiName), resEditTriggerText);
Assert.assertTrue(isTextPresent(jndiName));
clickAndWait(resTargetTabId, TRIGGER_EDIT_RESOURCE_TARGETS);
//Test the manage targets : Remove the instance and add the server.
clickAndWait("propertyForm:targetTable:topActionsGroup1:manageTargetButton", TRIGGER_MANAGE_TARGETS);
addSelectSelection("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove_selected", instanceName);
waitForButtonEnabled("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove:commonAddRemove_removeButton");
pressButton("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove:commonAddRemove_removeButton");
waitForButtonDisabled("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove:commonAddRemove_removeButton");
selenium.removeAllSelections("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove_available");
addSelectSelection("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove_available", DEFAULT_SERVER);
waitForButtonEnabled("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove:commonAddRemove_addButton");
pressButton("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove:commonAddRemove_addButton");
waitForButtonDisabled("form:targetSection:targetSectionId:addRemoveProp:commonAddRemove:commonAddRemove_addButton");
clickAndWait("form:propertyContentPage:topButtons:saveButton", TRIGGER_NEW_VALUES_SAVED);
waitForPageLoad(instanceName, false);
Assert.assertTrue(isTextPresent(DEFAULT_SERVER));
//Go Back to Resources Page
clickAndWait(resourcesLinkId, resourcesTriggerText);
}
protected void logDebugMessage(String message) {
if (DEBUG) {
logger.info(message);
}
}
protected String resolveTriggerText(String original) {
String triggerText = original;
int index = original.indexOf(".");
if (index > -1) {
String bundleName = original.substring(0, index);
String key = original.substring(index + 1);
String bundle = bundles.get(bundleName);
if (bundle != null) {
ResourceBundle res = ResourceBundle.getBundle(bundle);
if (res != null) {
// Strip out HTML. Hopefully this will be robust enough
triggerText = res.getString(key).replaceAll("<.*?>", "");
} else {
Logger.getLogger(BaseSeleniumTestClass.class.getName()).log(Level.WARNING, null, "An invalid resource bundle was specified: " + original);
}
}
}
return triggerText;
}
protected void log(String message, String... args) {
if (DEBUG) {
String[] temp = new String[args.length];
for (int i = 0; i < args.length; i++) {
temp[i] = resolveTriggerText(args[i]);
}
logger.log(Level.INFO, message, temp);
}
}
private void insureElementIsVisible (final String id) {
if (!id.contains("treeForm:tree")) {
return;
}
try {
RenderedWebElement element = (RenderedWebElement) elementFinder.findElement(By.id(id), TIMEOUT);
//driver.findElement(By.id(id));
if (element.isDisplayed()) {
return;
}
} catch (StaleElementReferenceException sere) {
}
final String parentId = id.substring(0, id.lastIndexOf(":"));
final RenderedWebElement parentElement = (RenderedWebElement) elementFinder.findElement(By.id(parentId), TIMEOUT);
// driver.findElement(By.id(parentId));
if (!parentElement.isDisplayed()) {
insureElementIsVisible(parentId);
String grandParentId = parentId.substring(0, parentId.lastIndexOf(":"));
String nodeId = grandParentId.substring(grandParentId.lastIndexOf(":")+1);
pressButton(grandParentId + ":" + nodeId+"_turner");
}
}
class PageLoadCallBack implements WaitForLoadCallBack {
boolean textShouldBeMissing;
String triggerText;
public PageLoadCallBack(String triggerText, boolean textShouldBeMissing) {
this.textShouldBeMissing = textShouldBeMissing;
this.triggerText = resolveTriggerText(triggerText);
}
@Override
public boolean executeTest() {
boolean found = false;
try {
if (isElementPresent("j_username") && !processingLogin) {
handleLogin();
}
if (!textShouldBeMissing) {
if (isTextPresent(triggerText)) {
found = true;
}
} else if (!isTextPresent(triggerText)) {
found = true;
} else {
if (isTextPresent("RuntimeException")) {
throw new RuntimeException("Exception detected on page. Please check the logs for details");
}
}
} catch (SeleniumException se) {
String message = se.getMessage();
if (!"ERROR: Couldn't access document.body. Is this HTML page fully loaded?".equals(se.getMessage())) {
throw new RuntimeException(se);
}
}
return found;
}
};
class DeleteRowCallBack implements WaitForLoadCallBack {
private String tableId;
private String tableRowValue;
private String tableColId;
public DeleteRowCallBack(String tableId, String tableRowValue, String tableColId) {
this.tableId = tableId;
this.tableRowValue = tableRowValue;
this.tableColId = tableColId;
}
@Override
public boolean executeTest() {
try {
List<String> rows = getTableRowsByValue(tableId, tableRowValue, tableColId);
return rows.isEmpty();
} catch (SeleniumException se) {
return false;
}
}
}
class AddTableRowCallBack implements WaitForLoadCallBack {
private final String tableId;
private final int initialCount;
public AddTableRowCallBack(String tableId, int initialCount) {
this.tableId = tableId;
this.initialCount = initialCount;
}
@Override
public boolean executeTest() {
int count = getTableRowCount(tableId);
return count > initialCount;
}
};
class ButtonDisabledStateCallBack implements WaitForLoadCallBack {
private String buttonId;
private boolean desiredState;
public ButtonDisabledStateCallBack(String buttonId, boolean desiredState) {
this.buttonId = buttonId;
this.desiredState = desiredState;
}
@Override
public boolean executeTest() {
// String attr = selenium.getEval("this.browserbot.findElement('id=" + buttonId + "').disabled"); // "Classic" Selenium
try {
String attr =
elementFinder.findElement(By.id(buttonId), TIMEOUT)
// driver.findElement(By.id(buttonId))
.getAttribute("disabled"); // WebDriver-backed Selenium
return (Boolean.parseBoolean(attr) == desiredState);
} catch (Exception ex) {
return true;// ???
}
}
}
}
Other Glassfish examples (source code examples)
Here is a short list of links related to this Glassfish BaseSeleniumTestClass.java source code file:
|
The search page
Other Glassfish source code examples at this package level
Click here to learn more about this project
