Class: Celerity::Browser

Inherits:
Object
  • Object
show all
Includes:
Container, XpathSupport
Defined in:
lib/celerity/browser.rb,
lib/celerity/watir_compatibility.rb

Class Attribute Summary collapse

Instance Attribute Summary collapse

Attributes included from Container

#browser

Class Method Summary collapse

Instance Method Summary collapse

Methods included from XpathSupport

#element_by_xpath, #element_from_dom_node, #elements_by_xpath

Methods included from Container

#area, #areas, #button, #buttons, #cell, #cells, #check_box, #checkboxes, #container=, #dd, #dds, #del, #dels, #div, #divs, #dl, #dls, #dt, #dts, #em, #ems, #file_field, #file_fields, #form, #forms, #frame, #frames, #h1, #h1s, #h2, #h2s, #h3, #h3s, #h4, #h4s, #h5, #h5s, #h6, #h6s, #hidden, #hiddens, #image, #images, #ins, #inses, #label, #labels, #li, #link, #links, #lis, #map, #maps, #meta, #metas, #ol, #ols, #option, #p, #pre, #pres, #ps, #radio, #radios, #row, #rows, #select_list, #select_lists, #span, #spans, #strong, #strongs, #table, #tables, #tbodies, #tbody, #text_field, #text_fields, #tfoot, #tfoots, #th, #thead, #theads, #ths, #ul, #uls

Methods included from ShortInspect

#short_inspect

Constructor Details

#initialize(opts = {}) ⇒ Celerity::Browser

Creates a browser object.

Parameters:

  • (defaults to: {})

    a customizable set of options

Options Hash (opts):

  • :browser (:internet_explorer, :firefox, :firefox3) — default: :firefox3 —

    Set the BrowserVersion used by HtmlUnit. Defaults to Firefox 3.

  • :charset (String) — default: "UTF-8" —

    Specify the charset that webclient will use for requests.

  • :css (Boolean) — default: true —

    Enable/disable CSS. Enabled by default.

  • :ignore_pattern (Regexp) —

    See Browser#ignore_pattern=

  • :javascript_enabled (Boolean) — default: true —

    Enable/disable JavaScript evaluation. Enabled by default.

  • :javascript_exceptions (Boolean) — default: false —

    Raise exceptions on script errors. Disabled by default.

  • :log_level (Symbol) — default: :warning —

    @see log_level=

  • :proxy (String) — default: nil —

    Proxy server to use, in address:port format.

  • :refresh_handler (:immediate, :waiting, :threaded) — default: :immediate —

    Set HtmlUnit's refresh handler.

  • :render (:html, :xml) — default: :html —

    What DOM representation to send to connected viewers.

  • :resynchronize (Boolean) — default: false —

    Use HtmlUnit::NicelyResynchronizingAjaxController to resynchronize Ajax calls.

  • :secure_ssl (Boolean) — default: true —

    Enable/disable secure SSL. Enabled by default.

  • :status_code_exceptions (Boolean) — default: false —

    Raise exceptions on failing status codes (404 etc.). Disabled by default.

  • :user_agent (String) —

    Override the User-Agent set by the :browser option

  • :default_wait (Integer) —

    The default number of seconds to wait when Browser#wait is called.

  • :viewer (String, false) — default: "127.0.0.1:6429" —

    Connect to a CelerityViewer if available.

Raises:

See Also:

API:

  • public



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
 
# File 'lib/celerity/browser.rb', line 57

def initialize(opts = {})
  unless opts.is_a?(Hash)
    raise TypeError, "wrong argument type #{opts.class}, expected Hash"
  end

  unless (render_types = [:html, :xml, nil, 'html', 'xml']).include?(opts[:render])
    raise ArgumentError, "expected one of #{render_types.inspect} for key :render"
  end

  @options = opts.dup # keep the unmodified version around as well
  opts     = opts.dup # we'll delete from opts, so dup to avoid side effects

  @render_type   = opts.delete(:render)    || :html
  @charset       = opts.delete(:charset)   || "UTF-8"
  @page           = nil
  @error_checkers = []
  @browser        = self # for Container#browser

  setup_webclient opts
  setup_viewer opts.delete(:viewer)

  self.log_level = opts.delete(:log_level) || :off

  raise ArgumentError, "unknown option #{opts.inspect}" unless opts.empty?
end

Class Attribute Details

.attach_timeout ⇒ Object

Added for Watir compatibility - not in use by Celerity



6
7
8
 
# File 'lib/celerity/watir_compatibility.rb', line 6

def attach_timeout
  @attach_timeout
end

.speed ⇒ Object

Added for Watir compatibility - not in use by Celerity



6
7
8
 
# File 'lib/celerity/watir_compatibility.rb', line 6

def speed
  @speed
end

.visible ⇒ Object

Added for Watir compatibility - not in use by Celerity



6
7
8
 
# File 'lib/celerity/watir_compatibility.rb', line 6

def visible
  @visible
end

Instance Attribute Details

#charset ⇒ Object

Returns the value of attribute charset.



6
7
8
 
# File 'lib/celerity/browser.rb', line 6

def charset
  @charset
end

#object ⇒ Object

Returns the value of attribute object.



6
7
8
 
# File 'lib/celerity/browser.rb', line 6

def object
  @object
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



7
8
9
 
# File 'lib/celerity/browser.rb', line 7

def options
  @options
end

#page ⇒ Object

Returns the value of attribute page.



6
7
8
 
# File 'lib/celerity/browser.rb', line 6

def page
  @page
end

#viewer ⇒ Object (readonly)

Returns the value of attribute viewer.



7
8
9
 
# File 'lib/celerity/browser.rb', line 7

def viewer
  @viewer
end

#visible ⇒ Object

Added for Watir compatibility - not in use by Celerity



14
15
16
 
# File 'lib/celerity/watir_compatibility.rb', line 14

def visible
  @visible
end

#webclient ⇒ Object (readonly)

Returns the value of attribute webclient.



7
8
9
 
# File 'lib/celerity/browser.rb', line 7

def webclient
  @webclient
end

Class Method Details

.attach(*args) ⇒ Object

Not implemented. Use ClickableElement#click_and_attach instead.

Raises:



26
27
28
 
# File 'lib/celerity/browser.rb', line 26

def self.attach(*args)
  raise NotImplementedError, "use ClickableElement#click_and_attach instead"
end

.each ⇒ Object

Added for Watir compatibility - not in use by Celerity



10
 
# File 'lib/celerity/watir_compatibility.rb', line 10

def each; end

.start(uri) ⇒ Celerity::Browser Also known as: start_window

Initialize a browser and go to the given URL

Parameters:

  • The URL to go to.

Returns:

  • instance.



16
17
18
19
20
 
# File 'lib/celerity/browser.rb', line 16

def self.start(uri)
  browser = new
  browser.goto(uri)
  browser
end

Instance Method Details

#add_checker(checker = nil) {|browser| ... } ⇒ Object

Add a 'checker' proc that will be run on every page load

Parameters:

  • (defaults to: nil)

    The proc to be run (can also be given as a block)

Yield Parameters:

Raises:

  • if no Proc or block was given.



578
579
580
581
582
583
584
585
586
 
# File 'lib/celerity/browser.rb', line 578

def add_checker(checker = nil, &block)
  if block_given?
    @error_checkers << block
  elsif Proc === checker
    @error_checkers << checker
  else
    raise ArgumentError, "argument must be a Proc or block"
  end
end

#add_cookie(domain, name, value, opts = {}) ⇒ Object

Add a cookie with the given parameters (Celerity only)

Parameters:

  • (defaults to: {})

    a customizable set of options

Options Hash (opts):

  • :path (String) — default: "/" —

    A path

  • :expires (Time) — default: 1 day from now —

    An expiration date

  • :secure (Boolean) — default: false

Raises:



356
357
358
359
360
361
362
363
364
365
366
367
 
# File 'lib/celerity/browser.rb', line 356

def add_cookie(domain, name, value, opts = {})
  path    = opts.delete(:path) || "/"
  max_age = opts.delete(:expires) || (Time.now + 60*60*24) # not sure if this is correct
  secure  = opts.delete(:secure) || false

  raise(ArgumentError, "unknown option: #{opts.inspect}") unless opts.empty?

  cookie = HtmlUnit::Util::Cookie.new(domain, name, value, path, max_age, secure)
  @webclient.getCookieManager.addCookie cookie

  cookie
end

#add_listener(type, &block) ⇒ Object

Add a listener block for one of the available types. (Celerity only) Types map to HtmlUnit interfaces like this:

:status           => StatusHandler
:alert            => AlertHandler  ( window.alert() )
:web_window_event => WebWindowListener
:html_parser      => HTMLParserListener
:incorrectness    => IncorrectnessListener
:confirm          => ConfirmHandler ( window.confirm() )
:prompt           => PromptHandler ( window.prompt() )

Examples:

browser.add_listener(:status) { |page, message| ... }
browser.add_listener(:alert) { |page, message| ... }
browser.add_listener(:web_window_event) { |web_window_event| ... }
browser.add_listener(:html_parser) { |message, url, line, column, key| ... }
browser.add_listener(:incorrectness) { |message, origin| ... }
browser.add_listener(:confirm) { |page, message| ...; true }
browser.add_listener(:prompt) { |page, message| ... }

Parameters:

  • One of the above symbols.

  • A block to be executed for events of this type.



544
545
546
 
# File 'lib/celerity/browser.rb', line 544

def add_listener(type, &block)
  listener.add_listener(type, &block)
end

#assert_exists ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check that we have a @page object.

Raises:

  • if no page is loaded.

API:

  • private



769
770
771
 
# File 'lib/celerity/browser.rb', line 769

def assert_exists
  raise UnknownObjectException, "no page loaded" unless exist?
end

#asynchronized {|browser| ... } ⇒ Object

Allows you to temporarliy switch to HtmlUnit's default AjaxController, so ajax calls are performed asynchronously. This is useful if you have created the Browser with :resynchronize => true, but want to switch it off temporarily.

Yield Parameters:

See Also:

  • #new


485
486
487
488
489
490
 
# File 'lib/celerity/browser.rb', line 485

def asynchronized(&block)
  old_controller = @webclient.ajaxController
  @webclient.setAjaxController(::HtmlUnit::AjaxController.new)
  yield self
  @webclient.setAjaxController(old_controller)
end

#back ⇒ String

Goto back one history item

Returns:

  • The url of the resulting page.



263
264
265
266
267
268
 
# File 'lib/celerity/browser.rb', line 263

def back
  @webclient.getCurrentWindow.getHistory.back
  refresh_page_from_window

  url
end

#bring_to_front ⇒ Object

Added for Watir compatibility - not in use by Celerity



17
 
# File 'lib/celerity/watir_compatibility.rb', line 17

def bring_to_front; true; end

#cache_limit ⇒ Object 



323
324
325
 
# File 'lib/celerity/browser.rb', line 323

def cache_limit
  @webclient.cache.getMaxSize
end

#cache_limit=(size) ⇒ Object

Set the maximum number of files to cache.



319
320
321
 
# File 'lib/celerity/browser.rb', line 319

def cache_limit=(size)
  @webclient.cache.setMaxSize(size)
end

#clear_cache ⇒ Object

Clears the cache of "compiled JavaScript files and parsed CSS snippets"



311
312
313
 
# File 'lib/celerity/browser.rb', line 311

def clear_cache
  @webclient.cache.clear
end

#clear_cookies ⇒ Object

Clears all cookies. (Celerity only)



303
304
305
 
# File 'lib/celerity/browser.rb', line 303

def clear_cookies
  @webclient.getCookieManager.clearCookies
end

#close ⇒ Object

Unsets the current page / closes all windows



131
132
133
134
135
136
 
# File 'lib/celerity/browser.rb', line 131

def close
  @page = nil
  @object = nil
  @webclient.closeAllWindows
  @viewer.close
end

#confirm(bool, &block) ⇒ Object

Specify a boolean value to click either 'OK' or 'Cancel' in any confirm dialogs that might show up during the duration of the given block.

(Celerity only)

Parameters:

  • true to click 'OK', false to click 'cancel'

  • A block that will trigger the confirm() call(s).



562
563
564
565
566
567
568
 
# File 'lib/celerity/browser.rb', line 562

def confirm(bool, &block)
  blk = lambda { bool }

  listener.add_listener(:confirm, &blk)
  yield
  listener.remove_listener(:confirm, blk)
end

#contains_text(expected_text) ⇒ Numeric?

Check if the current page contains the given text.

Parameters:

  • The text to look for.

Returns:

  • The index of the matched text, or nil if it isn't found.

Raises:



245
246
247
248
 
# File 'lib/celerity/browser.rb', line 245

def contains_text(expected_text)
  return nil unless exist?
  super
end

#content_type ⇒ String

Returns content-type as in 'text/html'.

Returns:

  • content-type as in 'text/html'



221
222
223
224
225
 
# File 'lib/celerity/browser.rb', line 221

def content_type
  return '' unless @page

  @page.getWebResponse.getContentType
end

#cookies ⇒ Hash<domain, Hash<name, value>>

Get the cookies for this session. (Celerity only)

Returns:



333
334
335
336
337
338
339
340
341
342
 
# File 'lib/celerity/browser.rb', line 333

def cookies
  result = Hash.new { |hash, key| hash[key] = {} }

  cookies = @webclient.getCookieManager.getCookies
  cookies.each do |cookie|
    result[cookie.getDomain][cookie.getName] = cookie.getValue
  end

  result
end

#credentials=(string) ⇒ Object

Set the credentials used for basic HTTP authentication. (Celerity only)

Example:

browser.credentials = "username:password"

Parameters:

  • string with username / password, separated by a colon



120
121
122
123
124
125
 
# File 'lib/celerity/browser.rb', line 120

def credentials=(string)
  user, pass = string.split(":")
  dcp = HtmlUnit::DefaultCredentialsProvider.new
  dcp.addCredentials(user, pass)
  @webclient.setCredentialsProvider(dcp)
end

#css ⇒ Object 



688
689
690
 
# File 'lib/celerity/browser.rb', line 688

def css
  @webclient.cssEnabled
end

#css=(bool) ⇒ Object

Turn on/off CSS loading

Parameters:



684
685
686
 
# File 'lib/celerity/browser.rb', line 684

def css=(bool)
  @webclient.cssEnabled = bool
end

#debug_web_connection(name, &blk) ⇒ Object

Start or stop HtmlUnit's DebuggingWebConnection. (Celerity only) The output will go to /tmp/«name»

Parameters:

  • directory name

  • block to execute



500
501
502
503
504
505
506
507
508
 
# File 'lib/celerity/browser.rb', line 500

def debug_web_connection(name, &blk)
  old_wc = @webclient.getWebConnection

  @webclient.setWebConnection HtmlUnit::Util::DebuggingWebConnection.new(old_wc, name)
  res = yield
  @webclient.setWebConnection old_wc

  res
end

#disable_checker(checker) ⇒ Object

Remove the given checker from the list of checkers

Parameters:

  • The Proc to disable.



593
594
595
 
# File 'lib/celerity/browser.rb', line 593

def disable_checker(checker)
  @error_checkers.delete(checker)
end

#disable_event_listener ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Disable Celerity's internal WebWindowEventListener

API:

  • private



801
802
803
804
805
806
807
808
809
810
 
# File 'lib/celerity/browser.rb', line 801

def disable_event_listener
  listener.remove_listener(:web_window_event, @event_listener)

  if block_given?
    result = yield
    enable_event_listener

    result
  end
end

#document ⇒ HtmlUnit::HtmlHtml

Returns the underlying HtmlUnit document.

Returns:

  • the underlying HtmlUnit document.



254
255
256
 
# File 'lib/celerity/browser.rb', line 254

def document
  @object
end

#enable_event_listener ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Enable Celerity's internal WebWindowEventListener

API:

  • private



787
788
789
790
791
792
793
 
# File 'lib/celerity/browser.rb', line 787

def enable_event_listener
  @event_listener ||= lambda do |event|
    self.page = @page ? @page.getEnclosingWindow.getEnclosedPage : event.getNewPage
  end

  listener.add_listener(:web_window_event, &@event_listener)
end

#execute_script(source) ⇒ Object

Execute the given JavaScript on the current page.

Returns:

  • The resulting Object



394
395
396
397
 
# File 'lib/celerity/browser.rb', line 394

def execute_script(source)
  assert_exists
  @page.executeJavaScript(source.to_s).getJavaScriptResult
end

#exist? ⇒ true, false Also known as: exists?

Checks if we have a page currently loaded.

Returns:



645
646
647
 
# File 'lib/celerity/browser.rb', line 645

def exist?
  !!@page
end

#focused_element ⇒ Object

Returns the element that currently has the focus (Celerity only)



777
778
779
 
# File 'lib/celerity/browser.rb', line 777

def focused_element
  element_from_dom_node(page.getFocusedElement())
end

#forward ⇒ String

Go forward one history item

Returns:

  • The url of the resulting page.



275
276
277
278
279
280
 
# File 'lib/celerity/browser.rb', line 275

def forward
  @webclient.getCurrentWindow.getHistory.forward
  refresh_page_from_window

  url
end

#goto(uri, headers = nil) ⇒ String

Goto the given URL

Parameters:

  • The url.

  • a Hash of HTTP headers to use for the request.

Returns:

  • The url.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/celerity/browser.rb', line 96

def goto(uri, headers = nil)
  uri = "http://#{uri}" unless uri =~ %r{://}

  request = HtmlUnit::WebRequest.new(::Java::JavaNet::URL.new(uri))

  request.setAdditionalHeaders(headers) if headers
  request.setCharset(@charset)

  rescue_status_code_exception do
    self.page = @webclient.getPage(request)
  end

  url()
end

#html ⇒ String

Returns the HTML content of the current page.

Returns:

  • the HTML content of the current page



167
168
169
170
171
 
# File 'lib/celerity/browser.rb', line 167

def html
  return '' unless @page

  @page.getWebResponse.getContentAsString(@charset)
end

#ignore_pattern=(regexp) ⇒ Object

If a request is made to an URL that matches the pattern set here, Celerity will ignore the request and return an empty page with content type "text/html" instead.

This is useful to block unwanted requests (like ads/banners).



632
633
634
635
636
637
638
 
# File 'lib/celerity/browser.rb', line 632

def ignore_pattern=(regexp)
  unless regexp.kind_of?(Regexp)
    raise TypeError, "expected Regexp, got #{regexp.inspect}:#{regexp.class}"
  end

  Celerity::IgnoringWebConnection.new(@webclient, regexp)
end

#inspect ⇒ Object 



83
84
85
 
# File 'lib/celerity/browser.rb', line 83

def inspect
  short_inspect :exclude => %w[@webclient @browser @object @options @listener @event_listener]
end

#io ⇒ IO?

Returns page contents as an IO, returns nil if no page is loaded.

Returns:

  • page contents as an IO, returns nil if no page is loaded.



231
232
233
234
235
 
# File 'lib/celerity/browser.rb', line 231

def io
  return nil unless @page

  @page.getWebResponse.getContentAsStream.to_io
end

#javascript_enabled ⇒ Object 



727
728
729
 
# File 'lib/celerity/browser.rb', line 727

def javascript_enabled
  @webclient.isJavaScriptEnabled
end

#javascript_enabled=(bool) ⇒ Object

Turn on/off JavaScript execution

Parameters:



723
724
725
 
# File 'lib/celerity/browser.rb', line 723

def javascript_enabled=(bool)
  @webclient.setJavaScriptEnabled(bool)
end

#javascript_exceptions ⇒ Object 



660
661
662
 
# File 'lib/celerity/browser.rb', line 660

def javascript_exceptions
  @webclient.throwExceptionOnScriptError
end

#javascript_exceptions=(bool) ⇒ Object

Turn on/off javascript exceptions

Parameters:



656
657
658
 
# File 'lib/celerity/browser.rb', line 656

def javascript_exceptions=(bool)
  @webclient.throwExceptionOnScriptError = bool
end

#log_level ⇒ Symbol

:finest, :finer, :fine, :config, :info, :warning, :severe, or :off, :all

Returns:

  • the current log level



603
604
605
 
# File 'lib/celerity/browser.rb', line 603

def log_level
  Celerity::Util.logger_for('com.gargoylesoftware.htmlunit').level.to_s.downcase.to_sym
end

#log_level=(level) ⇒ Object

Set Java log level (default is :warning, can be any of :all, :finest, :finer, :fine, :config, :info, :warning, :severe, :off)

Parameters:

  • The new log level.



613
614
615
616
617
618
619
620
621
622
623
 
# File 'lib/celerity/browser.rb', line 613

def log_level=(level)
  log_level = java.util.logging.Level.const_get(level.to_s.upcase)

  [ 'com.gargoylesoftware.htmlunit',
    'com.gargoylesoftware.htmlunit.html',
    'com.gargoylesoftware.htmlunit.javascript',
    'org.apache.commons.httpclient'
  ].each { |package| Celerity::Util.logger_for(package).level = log_level }

  level
end

#refresh ⇒ Object

Refresh the current page



294
295
296
297
 
# File 'lib/celerity/browser.rb', line 294

def refresh
  assert_exists
  @page.refresh
end

#refresh_handler=(symbol) ⇒ Object 



692
693
694
695
696
697
698
699
700
701
702
703
704
705
 
# File 'lib/celerity/browser.rb', line 692

def refresh_handler=(symbol)
  handler = case symbol
            when :waiting
              HtmlUnit::WaitingRefreshHandler.new
            when :threaded
              HtmlUnit::ThreadedRefreshHandler.new
            when :immediate
              HtmlUnit::ImmediateRefreshHandler.new
            else
              raise ArgumentError, "expected :waiting, :threaded or :immediate"
            end

  @webclient.setRefreshHandler handler
end

#remove_cookie(domain, name) ⇒ Object

Remove the cookie with the given domain and name (Celerity only)

Parameters:

Raises:

  • if the cookie doesn't exist



378
379
380
381
382
383
384
385
386
387
 
# File 'lib/celerity/browser.rb', line 378

def remove_cookie(domain, name)
  cm = @webclient.getCookieManager
  cookie = cm.getCookies.find { |c| c.getDomain == domain && c.getName == name }

  if cookie.nil?
    raise CookieNotFoundError, "no cookie with domain #{domain.inspect} and name #{name.inspect}"
  end

  cm.removeCookie(cookie)
end

#remove_listener(type, block) ⇒ Object 



548
549
550
 
# File 'lib/celerity/browser.rb', line 548

def remove_listener(type, block)
  listener.remove_listener(type, block)
end

#response_headers ⇒ Hash

Returns response headers as a hash.

Returns:

  • response headers as a hash



203
204
205
206
207
 
# File 'lib/celerity/browser.rb', line 203

def response_headers
  return {} unless @page

  Hash[*@page.getWebResponse.getResponseHeaders.map { |obj| [obj.name, obj.value] }.flatten]
end

#resynchronized {|browser| ... } ⇒ Object

Allows you to temporarily switch to HtmlUnit's NicelyResynchronizingAjaxController to resynchronize ajax calls.

@browser.resynchronized do |b|
b.link(:id, 'trigger_ajax_call').click
end

Yield Parameters:

See Also:

  • for how to configure the browser to always use this.


469
470
471
472
473
474
 
# File 'lib/celerity/browser.rb', line 469

def resynchronized(&block)
  old_controller = @webclient.ajaxController
  @webclient.setAjaxController(::HtmlUnit::NicelyResynchronizingAjaxController.new)
  yield self
  @webclient.setAjaxController(old_controller)
end

#secure_ssl=(bool) ⇒ Object

Turn on/off secure SSL

Parameters:



713
714
715
 
# File 'lib/celerity/browser.rb', line 713

def secure_ssl=(bool)
  @webclient.useInsecureSSL = !bool
end

#send_keys(keys) ⇒ Object

experimental - should be removed?



400
401
402
403
404
405
406
407
408
409
410
411
412
413
 
# File 'lib/celerity/browser.rb', line 400

def send_keys(keys)
  keys = keys.gsub(/\s*/, '').scan(/((?:\{[A-Z]+?\})|.)/u).flatten
  keys.each do |key|
    element = @page.getFocusedElement
    case key
    when "{TAB}"
      @page.tabToNextElement
    when /\w/
      element.type(key)
    else
      raise NotImplementedError
    end
  end
end

#speed=(s) ⇒ Object

Added for Watir compatibility - not in use by Celerity



19
 
# File 'lib/celerity/watir_compatibility.rb', line 19

def speed=(s); s end

#status ⇒ String

Returns the value of window.status.

Returns:

  • the value of window.status



159
160
161
 
# File 'lib/celerity/browser.rb', line 159

def status
  execute_script "window.status" # avoid the listener overhead
end

#status_code ⇒ Fixnum

Returns status code of the last request.

Returns:

  • status code of the last request



213
214
215
 
# File 'lib/celerity/browser.rb', line 213

def status_code
  @page.getWebResponse.getStatusCode
end

#status_code_exceptions ⇒ Object 



674
675
676
 
# File 'lib/celerity/browser.rb', line 674

def status_code_exceptions
  @webclient.throwExceptionOnFailingStatusCode
end

#status_code_exceptions=(bool) ⇒ Object

Turn on/off status code exceptions

Parameters:



670
671
672
 
# File 'lib/celerity/browser.rb', line 670

def status_code_exceptions=(bool)
  @webclient.throwExceptionOnFailingStatusCode = bool
end

#text ⇒ String

Returns a text representation of the current page.

Returns:

  • a text representation of the current page



187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/celerity/browser.rb', line 187

def text
  return '' unless @page

  if @page.respond_to?(:getContent)
    @page.getContent.strip
  elsif @page.respond_to?(:getDocumentElement) && doc = @page.getDocumentElement
    doc.asText.strip
  else
    ''
  end
end

#title ⇒ String

Returns the title of the current page.

Returns:

  • the title of the current page



151
152
153
 
# File 'lib/celerity/browser.rb', line 151

def title
  @page ? @page.getTitleText : ''
end

#trace_javascript(debugger_klass = Celerity::JavascriptDebugger, &blk) ⇒ Object 



510
511
512
513
514
515
 
# File 'lib/celerity/browser.rb', line 510

def trace_javascript(debugger_klass = Celerity::JavascriptDebugger, &blk)
  context_factory = @webclient.getJavaScriptEngine.getContextFactory
  context_factory.setDebugger debugger_klass.new
  yield
  context_factory.setDebugger nil
end

#url ⇒ String

Returns the URL of the current page.

Returns:

  • the URL of the current page



142
143
144
145
 
# File 'lib/celerity/browser.rb', line 142

def url
  assert_exists
  @page.getWebResponse.getWebRequest.getUrl.toString
end

#visual_debugger ⇒ Object

Open the JavaScript debugger GUI



735
736
737
 
# File 'lib/celerity/browser.rb', line 735

def visual_debugger
  HtmlUnit::Util::WebClientUtils.attachVisualDebugger @webclient
end

#wait(sec = @default_wait) ⇒ Object

Wait for javascript jobs to finish



285
286
287
288
 
# File 'lib/celerity/browser.rb', line 285

def wait(sec = @default_wait)
  assert_exists
  @webclient.waitForBackgroundJavaScript(sec * 1000);
end

#wait_until(timeout = 30) {|browser| ... } ⇒ Object

Wait until the given block evaluates to true (Celerity only)

Parameters:

  • (defaults to: 30)

    Number of seconds to wait before timing out (default: 30).

Yield Parameters:

See Also:



423
424
425
426
427
428
429
430
431
432
433
434
 
# File 'lib/celerity/browser.rb', line 423

def wait_until(timeout = 30, &block)
  returned = nil

  Timeout.timeout(timeout) do
    until returned = yield(self)
      refresh_page_from_window
      sleep 0.1
    end
  end

  returned
end

#wait_while(timeout = 30) {|browser| ... } ⇒ Object

Wait while the given block evaluates to true (Celerity only)

Parameters:

  • (defaults to: 30)

    Number of seconds to wait before timing out (default: 30).

Yield Parameters:

See Also:



444
445
446
447
448
449
450
451
452
453
454
455
 
# File 'lib/celerity/browser.rb', line 444

def wait_while(timeout = 30, &block)
  returned = nil

  Timeout.timeout(timeout) do
    while returned = yield(self)
      refresh_page_from_window
      sleep 0.1
    end
  end

  returned
end

#xml ⇒ String

Returns the XML representation of the DOM.

Returns:

  • the XML representation of the DOM



177
178
179
180
181
 
# File 'lib/celerity/browser.rb', line 177

def xml
  return '' unless @page
  return @page.asXml if @page.respond_to?(:asXml)
  return text # fallback to text (for exampel for "plain/text" pages)
end