Selenium Accessors part 6

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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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

Related Assertions, automatically generated:

• 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:

store	Mr	title
storeValue	nameField	surname
store	${title} ${surname}	fullname
type	textElement	Full name is: ${fullname}

Javascript evaluation
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.
The following examples try to give an indication of how Selenium can be extended with javascript.

Actions

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.
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);
 };
 

Accessors/Assertions

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.
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);
 };
 

Automatic availability of storeFoo, assertFoo, assertNotFoo, waitForFoo and waitForNotFoo for every getFoo

All getFoo and isFoo methods on the Selenium prototype automatically result in the availability of storeFoo, assertFoo, assertNotFoo, verifyFoo, verifyNotFoo, waitForFoo, and waitForNotFoo commands.
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.

Locator Strategies

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;
 };