Class Capybara::Node::Base
In: lib/capybara/node/base.rb
Parent: Object

A {Capybara::Node::Base} represents either an element on a page through the subclass {Capybara::Node::Element} or a document through {Capybara::Node::Document}.

Both types of Node share the same methods, used for interacting with the elements on the page. These methods are divided into three categories, finders, actions and matchers. These are found in the modules {Capybara::Node::Finders}, {Capybara::Node::Actions} and {Capybara::Node::Matchers} respectively.

A {Capybara::Session} exposes all methods from {Capybara::Node::Document} directly: 

    session = Capybara::Session.new(:rack_test, my_app)
    session.visit('/')
    session.fill_in('Foo', :with => 'Bar')    # from Capybara::Node::Actions
    bar = session.find('#bar')                # from Capybara::Node::Finders
    bar.select('Baz', :from => 'Quox')        # from Capybara::Node::Actions
    session.has_css?('#foobar')               # from Capybara::Node::Matchers

Methods

driver   new   reload   synchronize   unsynchronized  

Included Modules

Capybara::Node::Finders Capybara::Node::Actions Capybara::Node::Matchers

Attributes

base  [R] 
parent  [R] 
session  [R] 

Public Class methods

Public Instance methods

reload()

overridden in subclasses, e.g. Capybara::Node::Element

synchronize(seconds=Capybara.default_wait_time) {|| ...}

This method is Capybara‘s primary defence agains asynchronicity problems. It works by attempting to run a given block of code until it succeeds. The exact behaviour of this method depends on a number of factors. Basically there are certain exceptions which, when raised from the block, instead of bubbling up, are caught, and the block is re-run.

Certain drivers, such as RackTest, have no support for aynchronous processes, these drivers run the block, and any error raised bubbles up immediately. This allows faster turn around in the case where an expectation fails.

Only exceptions that are {Capybara::ElementNotFound} or any subclass thereof cause the block to be rerun. Drivers may specify additional exceptions which also cause reruns. This usually occurs when a node is manipulated which no longer exists on the page. For example, the Selenium driver specifies `Selenium::WebDriver::Error::ObsoleteElementError`.

As long as any of these exceptions are thrown, the block is re-run, until a certain amount of time passes. The amount of time defaults to {Capybara.default_wait_time} and can be overriden through the `seconds` argument. This time is compared with the system time to see how much time has passed. If the return value of {Time.now} is stubbed out, Capybara will raise `Capybara::FrozenInTime`.

@param [Integer] seconds Number of seconds to retry this block @return [Object] The result of the given block @raise [Capybara::FrozenInTime] If the return value of {Time.now} appears stuck

unsynchronized() {|| ...}

Within the given block, prevent synchronize from having any effect.

This is an internal method which should not be called unless you are absolutely sure of what you‘re doing.

@api private @return [Object] The result of the given block

Protected Instance methods

[Validate]