/
session.rb
322 lines (292 loc) · 9.12 KB
/
session.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
require 'capybara/util/timeout'
module Capybara
##
#
# The Session class represents a single user's interaction with the system. The Session can use
# any of the underlying drivers. A session can be initialized manually like this:
#
# session = Capybara::Session.new(:culerity, MyRackApp)
#
# The application given as the second argument is optional. When running Capybara against an external
# page, you might want to leave it out:
#
# session = Capybara::Session.new(:culerity)
# session.visit('http://www.google.com')
#
# Session provides a number of methods for controlling the navigation of the page, such as +visit+,
# +current_path, and so on. It also delegate a number of methods to a Capybara::Document, representing
# the current HTML document. This allows interaction:
#
# session.fill_in('q', :with => 'Capybara')
# session.click_button('Search')
# session.should have_content('Capybara')
#
# When using capybara/dsl, the Session is initialized automatically for you.
#
class Session
NODE_METHODS = [
:all, :first, :attach_file, :text, :check, :choose,
:click_link_or_button, :click_button, :click_link, :field_labeled,
:fill_in, :find, :find_button, :find_by_id, :find_field, :find_link,
:has_content?, :has_text?, :has_css?, :has_no_content?, :has_no_text?,
:has_no_css?, :has_no_xpath?,
:has_xpath?, :select, :uncheck, :has_link?, :has_no_link?, :has_button?,
:has_no_button?, :has_field?, :has_no_field?, :has_checked_field?,
:has_unchecked_field?, :has_no_table?, :has_table?, :unselect,
:has_select?, :has_no_select?, :has_selector?, :has_no_selector?,
:click_on, :has_no_checked_field?, :has_no_unchecked_field?
]
SESSION_METHODS = [
:body, :html, :current_url, :current_host, :evaluate_script, :source,
:visit, :wait_until, :within, :within_fieldset, :within_table,
:within_frame, :within_window, :current_path, :save_page,
:save_and_open_page, :reset_session!
]
DSL_METHODS = NODE_METHODS + SESSION_METHODS
attr_reader :mode, :app
def initialize(mode, app=nil)
@mode = mode
@app = app
end
def driver
@driver ||= begin
unless Capybara.drivers.has_key?(mode)
other_drivers = Capybara.drivers.keys.map { |key| key.inspect }
raise Capybara::DriverNotFoundError, "no driver called #{mode.inspect} was found, available drivers: #{other_drivers.join(', ')}"
end
Capybara.drivers[mode].call(app)
end
end
##
#
# Reset the session, removing all cookies.
#
def reset!
driver.reset!
end
alias_method :cleanup!, :reset!
alias_method :reset_session!, :reset!
##
#
# Returns a hash of response headers. Not supported by all drivers (e.g. Selenium)
#
# @return [Hash{String => String}] A hash of response headers.
#
def response_headers
driver.response_headers
end
##
#
# Returns the current HTTP status code as an Integer. Not supported by all drivers (e.g. Selenium)
#
# @return [Integer] Current HTTP status code
#
def status_code
driver.status_code
end
##
#
# @return [String] A snapshot of the HTML of the current document, as it looks right now (potentially modified by JavaScript).
#
def html
driver.body
end
##
#
# @return [String] HTML source of the document, before being modified by JavaScript.
#
def source
driver.source
end
alias_method :body, :source
##
#
# @return [String] Path of the current page, without any domain information
#
def current_path
path = URI.parse(current_url).path
path if path and not path.empty?
end
##
#
# @return [String] Host of the current page
#
def current_host
uri = URI.parse(current_url)
"#{uri.scheme}://#{uri.host}" if uri.host
end
##
#
# @return [String] Fully qualified URL of the current page
#
def current_url
driver.current_url
end
##
#
# Navigate to the given URL. The URL can either be a relative URL or an absolute URL
# The behaviour of either depends on the driver.
#
# session.visit('/foo')
# session.visit('http://google.com')
#
# For drivers which can run against an external application, such as culerity and selenium
# giving an absolute URL will navigate to that page. This allows testing applications
# running on remote servers. For these drivers, setting Capybara.app_host will make the
# remote server the default. For example:
#
# Capybara.app_host = 'http://google.com'
# session.visit('/') # visits the google homepage
#
# @param [String] url The URL to navigate to
#
def visit(url)
driver.visit(url)
end
##
#
# Execute the given block for a particular scope on the page. Within will find the first
# element matching the given selector and execute the block scoped to that element:
#
# within(:xpath, '//div[@id="delivery-address"]') do
# fill_in('Street', :with => '12 Main Street')
# end
#
# It is possible to omit the first parameter, in that case, the selector is assumed to be
# of the type set in Capybara.default_selector.
#
# within('div#delivery-address') do
# fill_in('Street', :with => '12 Main Street')
# end
#
# @overload within(*find_args)
# @param (see Capybara::Node::Finders#all)
#
# @overload within(a_node)
# @param [Capybara::Node::Base] a_node The node in whose scope the block should be evaluated
#
# @raise [Capybara::ElementNotFound] If the scope can't be found before time expires
#
def within(*args)
new_scope = if args.size == 1 && Capybara::Node::Base === args.first
args.first
else
find(*args)
end
begin
scopes.push(new_scope)
yield
ensure
scopes.pop
end
end
##
#
# Execute the given block within the a specific fieldset given the id or legend of that fieldset.
#
# @param [String] locator Id or legend of the fieldset
#
def within_fieldset(locator)
within :xpath, XPath::HTML.fieldset(locator) do
yield
end
end
##
#
# Execute the given block within the a specific table given the id or caption of that table.
#
# @param [String] locator Id or caption of the table
#
def within_table(locator)
within :xpath, XPath::HTML.table(locator) do
yield
end
end
##
#
# Execute the given block within the given iframe given the id of that iframe. Only works on
# some drivers (e.g. Selenium)
#
# @param [String] locator Id of the frame
#
def within_frame(frame_id)
driver.within_frame(frame_id) do
yield
end
end
##
#
# Execute the given block within the given window. Only works on
# some drivers (e.g. Selenium)
#
# @param [String] locator of the window
#
def within_window(handle, &blk)
driver.within_window(handle, &blk)
end
##
#
# Retry executing the block until a truthy result is returned or the timeout time is exceeded
#
# @param [Integer] timeout The amount of seconds to retry executing the given block
#
def wait_until(timeout = Capybara.default_wait_time)
Capybara.timeout(timeout,driver) { yield }
end
##
#
# Execute the given script, not returning a result. This is useful for scripts that return
# complex objects, such as jQuery statements. +execute_script+ should be used over
# +evaluate_script+ whenever possible.
#
# @param [String] script A string of JavaScript to execute
#
def execute_script(script)
driver.execute_script(script)
end
##
#
# Evaluate the given JavaScript and return the result. Be careful when using this with
# scripts that return complex objects, such as jQuery statements. +execute_script+ might
# be a better alternative.
#
# @param [String] script A string of JavaScript to evaluate
# @return [Object] The result of the evaluated JavaScript (may be driver specific)
#
def evaluate_script(script)
driver.evaluate_script(script)
end
##
#
# Save a snapshot of the page and open it in a browser for inspection
#
def save_page
require 'capybara/util/save_and_open_page'
Capybara.save_page(body)
end
def save_and_open_page
require 'capybara/util/save_and_open_page'
Capybara.save_and_open_page(body)
end
def document
@document ||= Capybara::Node::Document.new(self, driver)
end
NODE_METHODS.each do |method|
class_eval <<-RUBY
def #{method}(*args, &block)
current_node.send(:#{method}, *args, &block)
end
RUBY
end
def inspect
%(#<Capybara::Session>)
end
private
def current_node
scopes.last
end
def scopes
@scopes ||= [document]
end
end
end