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.



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:

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


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:

  • type (Symbol) —

    One of the above symbols.

  • block (Proc) —

    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:



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:

  • (String) —

    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:

  • bool (Boolean) —

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

  • block (Proc) —

    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:

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


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:

  • (String) —

    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:

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


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:

  • A (String) —

    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:

  • (Bool) 


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:

  • name (String) —

    directory name

  • blk (block) —

    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:

  • checker (Proc) —

    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



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:

  • (HtmlUnit::HtmlHtml) —

    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



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:

  • (Object) —

    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:

  • (true, false) 


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:

  • (String) —

    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:

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

  • (String) —

    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:

  • (IO, nil) —

    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:

  • (Bool) 


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:

  • (Bool) 


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:

  • (Symbol) —

    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:

  • level (Symbol) —

    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:

  • domain (String)
  • name (String)

Raises:



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:

  • (Hash) —

    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:

  • (Bool) 


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:

  • (String) —

    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:

  • (Fixnum) —

    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:

  • (Bool) 


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:

  • (String) —

    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:

  • (String) —

    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:

  • (String) —

    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:

  • timeout (Fixnum) (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:

  • timeout (Fixnum) (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:

  • (String) —

    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