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:

  • opts (Hash) (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:

  • (ArgumentError)

See Also:



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:

  • (NotImplementedError) 


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:

  • uri (String) —

    The URL to go to.

Returns:



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:

  • checker (Proc) (defaults to: nil) —

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

Yield Parameters:

Raises:

  • (ArgumentError) —

    if no Proc or block was given.



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

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:

  • domain (String)
  • name (String)
  • value (String)
  • opts (Hash) (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:

  • (ArgumentError) 


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

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:

  • type (Symbol) —

    One of the above symbols.

  • block (Proc) —

    A block to be executed for events of this type.



542
543
544
 
# File 'lib/celerity/browser.rb', line 542

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:



767
768
769
 
# File 'lib/celerity/browser.rb', line 767

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


483
484
485
486
487
488
 
# File 'lib/celerity/browser.rb', line 483

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:

  • (String) —

    The url of the resulting page.



261
262
263
264
265
266
 
# File 'lib/celerity/browser.rb', line 261

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 



321
322
323
 
# File 'lib/celerity/browser.rb', line 321

def cache_limit
  @webclient.cache.getMaxSize
end

#cache_limit=(size) ⇒ Object

Set the maximum number of files to cache.



317
318
319
 
# File 'lib/celerity/browser.rb', line 317

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

#clear_cache ⇒ Object

Clears the cache of “compiled JavaScript files and parsed CSS snippets”



309
310
311
 
# File 'lib/celerity/browser.rb', line 309

def clear_cache
  @webclient.cache.clear
end

#clear_cookies ⇒ Object

Clears all cookies. (Celerity only)



301
302
303
 
# File 'lib/celerity/browser.rb', line 301

def clear_cookies
  @webclient.getCookieManager.clearCookies
end

#close ⇒ Object

Unsets the current page / closes all windows



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

def close
  @page = 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:

  • bool (Boolean) —

    true to click ‘OK’, false to click ‘cancel’

  • block (Proc) —

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



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

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:

  • expected_text (String, Regexp) —

    The text to look for.

Returns:

  • (Numeric, nil) —

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

Raises:

  • (TypeError) 


243
244
245
246
 
# File 'lib/celerity/browser.rb', line 243

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

#content_type ⇒ String

Returns content-type as in ‘text/html’.

Returns:

  • (String) —

    content-type as in ‘text/html’



219
220
221
222
223
 
# File 'lib/celerity/browser.rb', line 219

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:

  • (Hash<domain, Hash<name, value>>) 


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

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:

  • A (String) —

    string with username / password, separated by a colon



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

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

#css ⇒ Object 



686
687
688
 
# File 'lib/celerity/browser.rb', line 686

def css
  @webclient.cssEnabled
end

#css=(bool) ⇒ Object

Turn on/off CSS loading

Parameters:

  • (Bool) 


682
683
684
 
# File 'lib/celerity/browser.rb', line 682

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:

  • name (String) —

    directory name

  • blk (block) —

    block to execute



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

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:

  • checker (Proc) —

    The Proc to disable.



591
592
593
 
# File 'lib/celerity/browser.rb', line 591

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



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

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:

  • (HtmlUnit::HtmlHtml) —

    the underlying HtmlUnit document.



252
253
254
 
# File 'lib/celerity/browser.rb', line 252

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



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

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:

  • (Object) —

    The resulting Object



392
393
394
395
 
# File 'lib/celerity/browser.rb', line 392

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:

  • (true, false) 


643
644
645
 
# File 'lib/celerity/browser.rb', line 643

def exist?
  !!@page
end

#focused_element ⇒ Object

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



775
776
777
 
# File 'lib/celerity/browser.rb', line 775

def focused_element
  element_from_dom_node(page.getFocusedElement())
end

#forward ⇒ String

Go forward one history item

Returns:

  • (String) —

    The url of the resulting page.



273
274
275
276
277
278
 
# File 'lib/celerity/browser.rb', line 273

def forward
  @webclient.getCurrentWindow.getHistory.forward
  refresh_page_from_window

  url
end

#goto(uri, headers = nil) ⇒ String

Goto the given URL

Parameters:

  • uri (String) —

    The url.

  • (optional) (Hash) —

    a Hash of HTTP headers to use for the request.

Returns:

  • (String) —

    The url.



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

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

  request = HtmlUnit::WebRequestSettings.new(::Java::JavaNet::URL.new(uri))
  request.set_additional_headers(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:

  • (String) —

    the HTML content of the current page



165
166
167
168
169
 
# File 'lib/celerity/browser.rb', line 165

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



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

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:

  • (IO, nil) —

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



229
230
231
232
233
 
# File 'lib/celerity/browser.rb', line 229

def io
  return nil unless @page

  @page.getWebResponse.getContentAsStream.to_io
end

#javascript_enabled ⇒ Object 



725
726
727
 
# File 'lib/celerity/browser.rb', line 725

def javascript_enabled
  @webclient.isJavaScriptEnabled
end

#javascript_enabled=(bool) ⇒ Object

Turn on/off JavaScript execution

Parameters:

  • (Bool) 


721
722
723
 
# File 'lib/celerity/browser.rb', line 721

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

#javascript_exceptions ⇒ Object 



658
659
660
 
# File 'lib/celerity/browser.rb', line 658

def javascript_exceptions
  @webclient.throwExceptionOnScriptError
end

#javascript_exceptions=(bool) ⇒ Object

Turn on/off javascript exceptions

Parameters:

  • (Bool) 


654
655
656
 
# File 'lib/celerity/browser.rb', line 654

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

#log_level ⇒ Symbol

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

Returns:

  • (Symbol) —

    the current log level



601
602
603
 
# File 'lib/celerity/browser.rb', line 601

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:

  • level (Symbol) —

    The new log level.



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

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



292
293
294
295
 
# File 'lib/celerity/browser.rb', line 292

def refresh
  assert_exists
  @page.refresh
end

#refresh_handler=(symbol) ⇒ Object 



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

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:

  • domain (String)
  • name (String)

Raises:



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

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 



546
547
548
 
# File 'lib/celerity/browser.rb', line 546

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

#response_headers ⇒ Hash

Returns response headers as a hash.

Returns:

  • (Hash) —

    response headers as a hash



201
202
203
204
205
 
# File 'lib/celerity/browser.rb', line 201

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.


467
468
469
470
471
472
 
# File 'lib/celerity/browser.rb', line 467

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:

  • (Bool) 


711
712
713
 
# File 'lib/celerity/browser.rb', line 711

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

#send_keys(keys) ⇒ Object

experimental - should be removed?



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

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:

  • (String) —

    the value of window.status



157
158
159
 
# File 'lib/celerity/browser.rb', line 157

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

#status_code ⇒ Fixnum

Returns status code of the last request.

Returns:

  • (Fixnum) —

    status code of the last request



211
212
213
 
# File 'lib/celerity/browser.rb', line 211

def status_code
  @page.getWebResponse.getStatusCode
end

#status_code_exceptions ⇒ Object 



672
673
674
 
# File 'lib/celerity/browser.rb', line 672

def status_code_exceptions
  @webclient.throwExceptionOnFailingStatusCode
end

#status_code_exceptions=(bool) ⇒ Object

Turn on/off status code exceptions

Parameters:

  • (Bool) 


668
669
670
 
# File 'lib/celerity/browser.rb', line 668

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

#text ⇒ String

Returns a text representation of the current page.

Returns:

  • (String) —

    a text representation of the current page



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

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:

  • (String) —

    the title of the current page



149
150
151
 
# File 'lib/celerity/browser.rb', line 149

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

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



508
509
510
511
512
513
 
# File 'lib/celerity/browser.rb', line 508

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:

  • (String) —

    the URL of the current page



140
141
142
143
 
# File 'lib/celerity/browser.rb', line 140

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

#visual_debugger ⇒ Object

Open the JavaScript debugger GUI



733
734
735
 
# File 'lib/celerity/browser.rb', line 733

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

#wait(sec = @default_wait) ⇒ Object

Wait for javascript jobs to finish



283
284
285
286
 
# File 'lib/celerity/browser.rb', line 283

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:

  • timeout (Fixnum) (defaults to: 30) —

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

Yield Parameters:

See Also:



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

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:

  • timeout (Fixnum) (defaults to: 30) —

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

Yield Parameters:

See Also:



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

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:

  • (String) —

    the XML representation of the DOM



175
176
177
178
179
 
# File 'lib/celerity/browser.rb', line 175

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