- storeText ( locator, variableName )
- Gets the text of an element. This works for any element that contains
text. This command uses either the textContent (Mozilla-like browsers) or
the innerText (IE-like browsers) of the element, which is the rendered
text shown to the user.Arguments:
- locator - an element locator
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- the text of the element
- assertText ( locator, pattern )
- assertNotText ( locator, pattern )
- verifyText ( locator, pattern )
- verifyNotText ( locator, pattern )
- waitForText ( locator, pattern )
- waitForNotText ( locator, pattern )
- storeTitle ( variableName )
- Gets the title of the current page.
- Returns:
- the title of the current page
- assertTitle ( pattern )
- assertNotTitle ( pattern )
- verifyTitle ( pattern )
- verifyNotTitle ( pattern )
- waitForTitle ( pattern )
- waitForNotTitle ( pattern )
- storeValue ( locator, variableName )
- Gets the (whitespace-trimmed) value of an input field (or anything else with a value parameter).
For checkbox/radio elements, the value will be "on" or "off" depending on
whether the element is checked or not.Arguments:
- locator - an element locator
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- the element value, or "on/off" for checkbox/radio elements
- assertValue ( locator, pattern )
- assertNotValue ( locator, pattern )
- verifyValue ( locator, pattern )
- verifyNotValue ( locator, pattern )
- waitForValue ( locator, pattern )
- waitForNotValue ( locator, pattern )
- storeWhetherThisFrameMatchFrameExpression ( currentFrameString, target, variableName )
- Determine whether current/locator identify the frame containing this running code.
This is useful in proxy injection mode, where this code runs in every
browser frame and window, and sometimes the selenium server needs to identify
the "current" frame. In this case, when the test calls selectFrame, this
routine is called for each frame to figure out which one has been selected.
The selected frame will return true, while all others will return false.
Arguments:
- currentFrameString - starting frame
- target - new frame (which might be relative to the current one)
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if the new frame is this code's window
- assertWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
- assertNotWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
- verifyWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
- verifyNotWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
- waitForWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
- waitForNotWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
- storeAlertPresent ( variableName )
- Has an alert occurred?
This function never throws an exception
- Returns:
- true if there is an alert
- assertAlertPresent ( )
- assertAlertNotPresent ( )
- verifyAlertPresent ( )
- verifyAlertNotPresent ( )
- waitForAlertPresent ( )
- waitForAlertNotPresent ( )
- storeChecked ( locator, variableName )
- Gets whether a toggle-button (checkbox/radio) is checked. Fails if
the specified element doesn't exist or isn't a toggle-button.Arguments:
- locator - an element locator pointing to a checkbox or radio button
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if the checkbox is checked, false otherwise
- assertChecked ( locator )
- assertNotChecked ( locator )
- verifyChecked ( locator )
- verifyNotChecked ( locator )
- waitForChecked ( locator )
- waitForNotChecked ( locator )
- storeConfirmationPresent ( variableName )
- Has confirm() been called?
This function never throws an exception
- Returns:
- true if there is a pending confirmation
- assertConfirmationPresent ( )
- assertConfirmationNotPresent ( )
- verifyConfirmationPresent ( )
- verifyConfirmationNotPresent ( )
- waitForConfirmationPresent ( )
- waitForConfirmationNotPresent ( )
- storeEditable ( locator, variableName )
- Determines whether the specified input element is editable, ie hasn't been disabled.
This method will fail if the specified element isn't an input element.Arguments:
- locator - an element locator
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if the input element is editable, false otherwise
- assertEditable ( locator )
- assertNotEditable ( locator )
- verifyEditable ( locator )
- verifyNotEditable ( locator )
- waitForEditable ( locator )
- waitForNotEditable ( locator )
- storeElementPresent ( locator, variableName )
- Verifies that the specified element is somewhere on the page.Arguments:
- locator - an element locator
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if the element is present, false otherwise
- assertElementPresent ( locator )
- assertElementNotPresent ( locator )
- verifyElementPresent ( locator )
- verifyElementNotPresent ( locator )
- waitForElementPresent ( locator )
- waitForElementNotPresent ( locator )
- storeOrdered ( locator1, locator2, variableName )
- Check if these two elements have same parent and are ordered. Two same elements will
not be considered ordered.Arguments:
- locator1 - an element locator pointing to the first element
- locator2 - an element locator pointing to the second element
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if two elements are ordered and have same parent, false otherwise
- assertOrdered ( locator1, locator2 )
- assertNotOrdered ( locator1, locator2 )
- verifyOrdered ( locator1, locator2 )
- verifyNotOrdered ( locator1, locator2 )
- waitForOrdered ( locator1, locator2 )
- waitForNotOrdered ( locator1, locator2 )
- storePromptPresent ( variableName )
- Has a prompt occurred?
This function never throws an exception
- Returns:
- true if there is a pending prompt
- assertPromptPresent ( )
- assertPromptNotPresent ( )
- verifyPromptPresent ( )
- verifyPromptNotPresent ( )
- waitForPromptPresent ( )
- waitForPromptNotPresent ( )
- storeSomethingSelected ( selectLocator, variableName )
- Determines whether some option in a drop-down menu is selected.Arguments:
- selectLocator - an element locator identifying a drop-down menu
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if some option has been selected, false otherwise
- assertSomethingSelected ( selectLocator )
- assertNotSomethingSelected ( selectLocator )
- verifySomethingSelected ( selectLocator )
- verifyNotSomethingSelected ( selectLocator )
- waitForSomethingSelected ( selectLocator )
- waitForNotSomethingSelected ( selectLocator )
- storeTextPresent ( pattern, variableName )
- Verifies that the specified text pattern appears somewhere on the rendered page shown to the user.Arguments:
- pattern - a pattern to match with the text of the page
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if the pattern matches the text, false otherwise
- assertTextPresent ( pattern )
- assertTextNotPresent ( pattern )
- verifyTextPresent ( pattern )
- verifyTextNotPresent ( pattern )
- waitForTextPresent ( pattern )
- waitForTextNotPresent ( pattern )
- storeVisible ( locator, variableName )
- Determines if the specified element is visible. An
element can be rendered invisible by setting the CSS "visibility"
property to "hidden", or the "display" property to "none", either for the
element itself or one if its ancestors. This method will fail if
the element is not present.Arguments:
- locator - an element locator
- variableName - the name of a variable in which the result is to be stored.
- Returns:
- true if the specified element is visible, false otherwise
- assertVisible ( locator )
- assertNotVisible ( locator )
- verifyVisible ( locator )
- verifyNotVisible ( locator )
- waitForVisible ( locator )
- waitForNotVisible ( locator )
Parameter construction and Variables
All Selenium command parameters can be constructed using both simple variable substitution as well as full javascript. Both of these mechanisms can access previously stored variables, but do so using different syntax.
Stored Variables
The commands store, storeValue and storeText can be used to store a variable value for later access. Internally, these variables are stored in a map called "storedVars", with values keyed by the variable name. These commands are documented in the command reference.
Variable substitution
Variable substitution provides a simple way to include a previously stored variable in a command parameter. This is a simple mechanism, by which the variable to substitute is indicated by ${variableName}. Multiple variables can be substituted, and intermixed with static text.
Example:
Javascript evaluation
store Mr title storeValue nameField surname store ${title} ${surname} fullname type textElement Full name is: ${fullname}
Javascript evaluation provides the full power of javascript in constructing a command parameter. To use this mechanism, the entire parameter value must be prefixed by 'javascript{' with a trailing '}'. The text inside the braces is evaluated as a javascript expression, and can access previously stored variables using the storedVars map detailed above. Note that variable substitution cannot be combined with javascript evaluation.
Example:
store javascript{'merchant' + (new Date()).getTime()} merchantId type textElement javascript{storedVars['merchantId'].toUpperCase()}
Extending Selenium
It can be quite simple to extend Selenium, adding your own actions, assertions and locator-strategies. This is done with javascript by adding methods to the Selenium object prototype, and the PageBot object prototype. On startup, Selenium will automatically look through methods on these prototypes, using name patterns to recognise which ones are actions, assertions and locators.Actions
The following examples try to give an indication of how Selenium can be extended with javascript.
All doFoo methods on the Selenium prototype are added as actions. For each action foo there is also an action fooAndWait registered. An action method can take up to 2 parameters, which will be passed the second and third column values in the test.Accessors/Assertions
Example: Add a "typeRepeated" action to Selenium, which types the text twice into a text box.
Selenium.prototype.doTypeRepeated = function(locator, text) { // All locator-strategies are automatically handled by "findElement" var element = this.page().findElement(locator); // Create the text to type var valueToType = text + text; // Replace the element text with the new text this.page().replaceText(element, valueToType); };
All getFoo and isFoo methods on the Selenium prototype are added as accessors (storeFoo). For each accessor there is an assertFoo, verifyFoo and waitForFoo registered. An assert method can take up to 2 parameters, which will be passed the second and third column values in the test. You can also define your own assertions literally as simple "assert" methods, which will also auto-generate "verify" and "waitFor" commands.Automatic availability of storeFoo, assertFoo, assertNotFoo, waitForFoo and waitForNotFoo for every getFoo
Example: Add a valueRepeated assertion, that makes sure that the element value consists of the supplied text repeated. The 2 commands that would be available in tests would be assertValueRepeated and verifyValueRepeated.
Selenium.prototype.assertValueRepeated = function(locator, text) { // All locator-strategies are automatically handled by "findElement" var element = this.page().findElement(locator); // Create the text to verify var expectedValue = text + text; // Get the actual element value var actualValue = element.value; // Make sure the actual value matches the expected Assert.matches(expectedValue, actualValue); };
All getFoo and isFoo methods on the Selenium prototype automatically result in the availability of storeFoo, assertFoo, assertNotFoo, verifyFoo, verifyNotFoo, waitForFoo, and waitForNotFoo commands.Locator Strategies
Example, if you add a getTextLength() method, the following commands will automatically be available: storeTextLength, assertTextLength, assertNotTextLength, verifyTextLength, verifyNotTextLength, waitForTextLength, and waitForNotTextLength commands.
Selenium.prototype.getTextLength = function(locator, text) { return this.getText(locator).length; };Also note that the assertValueRepeated method described above could have been implemented using isValueRepeated, with the added benefit of also automatically getting assertNotValueRepeated, storeValueRepeated, waitForValueRepeated and waitForNotValueRepeated.
All locateElementByFoo methods on the PageBot prototype are added as locator-strategies. A locator strategy takes 2 parameters, the first being the locator string (minus the prefix), and the second being the document in which to search.
Example: Add a "valuerepeated=" locator, that finds the first element a value attribute equal to the the supplied value repeated.
// The "inDocument" is a the document you are searching. PageBot.prototype.locateElementByValueRepeated = function(text, inDocument) { // Create the text to search for var expectedValue = text + text; // Loop through all elements, looking for ones that have // a value === our expected value var allElements = inDocument.getElementsByTagName("*"); for (var i = 0; i < allElements.length; i++) { var testElement = allElements[i]; if (testElement.value && testElement.value === expectedValue) { return testElement; } } return null; };
