Module: Selenium::Client::Extensions

Included in:
Base
Defined in:
lib/selenium/client/extensions.rb

Overview

Convenience methods not explicitely part of the protocol

Instance Method Summary collapse

Instance Method Details

#active_javascript_framework(options) ⇒ Object 



111
112
113
 
# File 'lib/selenium/client/extensions.rb', line 111

def active_javascript_framework(options)
  options[:javascript_framework] || default_javascript_framework
end

#wait_for_ajax(options = {}) ⇒ Object

These for all Ajax request to finish (Only works if you are using prototype, the wait happens in the browser)

See davidvollbracht.com/2008/6/4/30-days-of-tech-day-3-waitforajax for more background.



11
12
13
14
15
 
# File 'lib/selenium/client/extensions.rb', line 11

def wait_for_ajax(options={})
builder = JavascriptExpressionBuilder.new active_javascript_framework(options)
 wait_for_condition builder.no_pending_ajax_requests.script,
                    options[:timeout_in_seconds]
end

#wait_for_effects(options = {}) ⇒ Object

Wait for all Prototype effects to be processed (the wait happens in the browser).

Credits to github.com/brynary/webrat/tree/master



20
21
22
23
24
 
# File 'lib/selenium/client/extensions.rb', line 20

def wait_for_effects(options={})
   builder = JavascriptExpressionBuilder.new active_javascript_framework(options)
  wait_for_condition builder.no_pending_effects.script,
                     options[:timeout_in_seconds]
end

#wait_for_element(locator, options = {}) ⇒ Object

Wait for an element to be present (the wait happens in the browser).



27
28
29
30
31
 
# File 'lib/selenium/client/extensions.rb', line 27

def wait_for_element(locator, options={})
  builder = JavascriptExpressionBuilder.new
  builder.find_element(locator).append("element != null;")
  wait_for_condition builder.script, options[:timeout_in_seconds]
end

#wait_for_field_value(locator, expected_value, options = {}) ⇒ Object

Wait for a field to get a specific value (the wait happens in the browser).



86
87
88
89
90
 
# File 'lib/selenium/client/extensions.rb', line 86

def wait_for_field_value(locator, expected_value, options={})
  builder = JavascriptExpressionBuilder.new
  builder.find_element(locator).element_value_is(expected_value)
  wait_for_condition builder.script, options[:timeout_in_seconds]
end

#wait_for_no_element(locator, options = {}) ⇒ Object

Wait for an element to NOT be present (the wait happens in the browser).



34
35
36
37
38
 
# File 'lib/selenium/client/extensions.rb', line 34

def wait_for_no_element(locator, options={})
  builder = JavascriptExpressionBuilder.new
  builder.find_element(locator).append("element == null;")
  wait_for_condition builder.script, options[:timeout_in_seconds]
end

#wait_for_no_field_value(locator, expected_value, options = {}) ⇒ Object

Wait for a field to not have a specific value (the wait happens in the browser).



93
94
95
96
97
 
# File 'lib/selenium/client/extensions.rb', line 93

def wait_for_no_field_value(locator, expected_value, options={})
  builder = JavascriptExpressionBuilder.new
  builder.find_element(locator).element_value_is_not(expected_value)
  wait_for_condition builder.script, options[:timeout_in_seconds]
end

#wait_for_no_text(pattern, options = {}) ⇒ Object

Wait for some text to NOT be present (the wait happens in the browser).

See wait_for_text for usage details.



79
80
81
82
83
 
# File 'lib/selenium/client/extensions.rb', line 79

def wait_for_no_text(pattern, options={})
  builder = JavascriptExpressionBuilder.new
builder.find_text(pattern, options).append("text_match == false;")
  wait_for_condition builder.script, options[:timeout_in_seconds]
end

#wait_for_not_visible(locator, options = {}) ⇒ Object

Wait for something to not be visible (the wait happens in the browser).



106
107
108
109
 
# File 'lib/selenium/client/extensions.rb', line 106

def wait_for_not_visible(locator, options={})
  builder = JavascriptExpressionBuilder.new
  wait_for_condition builder.not_visible(locator).script, options[:timeout_in_seconds]
end

#wait_for_text(pattern, options = {}) ⇒ Object

wait_for_text will search for the given argument within the innerHTML of the current DOM. Note that this method treats a single string as a special case.

Parameters

wait_for_text accepts an optional hash of parameters:

  • :element - a selenium locator for an element limiting the search scope.

  • :timeout_in_seconds - duration in seconds after which we time out if text cannot be found.

Regular Expressions

In addition to plain strings, wait_for_text accepts regular expressions as the pattern specification.

Examples

The following are equivalent, and will match “some text” anywhere within the document:

wait_for_text "some text"
wait_for_text /some text/

This will match “some text” anywhere within the specified element:

wait_for_text /some text/, :element => "container"

This will match “some text” only if it exactly matches the complete innerHTML of the specified element:

wait_for_text "some text", :element => "container"



70
71
72
73
74
 
# File 'lib/selenium/client/extensions.rb', line 70

def wait_for_text(pattern, options={})
  builder = JavascriptExpressionBuilder.new
builder.find_text(pattern, options).append("text_match == true;")
  wait_for_condition builder.script, options[:timeout_in_seconds]
end

#wait_for_visible(locator, options = {}) ⇒ Object

Wait for something to be visible (the wait happens in the browser).



100
101
102
103
 
# File 'lib/selenium/client/extensions.rb', line 100

def wait_for_visible(locator, options={})
  builder = JavascriptExpressionBuilder.new
  wait_for_condition builder.visible(locator).script, options[:timeout_in_seconds]
end