capybara 2.2.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f461ce522452cc01f332856bf2d2adc68364c19a
-  data.tar.gz: 2ecab34b9e3dfd9d2df9a027d094e52995fe33fc
+  metadata.gz: 9aa9a8cc20ae71dd404a731f98867ba19be9d4f2
+  data.tar.gz: 58b4097a52c34c878ceca8b9bf8477bc20a6e32a
 SHA512:
-  metadata.gz: 68b4bca1f71303ea1d24aaf849615d89773fcfacdff28c506e1d93de4592ad5b3f12d5c01ba3ff09756c36094421361207e0345651aa55544d124c636409e88e
-  data.tar.gz: 1bcafd2a83f248ccdfa86c5fe01b81b7865687b622464245594e307e875d4dba3c9acaddf909df84b1a392eb2f4fc012bd4457901d0e245b9dcebb291cf0d921
+  metadata.gz: 4f49792d051b3a87893c10becbb4866eff4cee8a6e9d146a3adfec388df1373c1fe382c390ac9f982de24845c8ea4297a0f168ade5318c628611d1043752cafb
+  data.tar.gz: c707670017ac8f9b9cd335c1cd006724f84d56747c79f7e4ebf4203b4cdac39fa3e211b11c7c8e2819dbd8556bb2c49876e945c37328c47e84bc465e679aa034

data/History.md

@@ -1,3 +1,29 @@
+# Version 2.3.0
+
+Release date: 2014-06-02
+
+### Added
+* New window management API [Andrey Botalov]
+* Speed improvement for visible text detection in RackTest [Thomas Walpole]
+  Thanks to Phillipe Creux for instigating this
+* RSpec 3 compatability
+* 'save_and_open_screenshot' functionality [Greg Lazarev]
+* Server errors raised on visit and synchronize [Jonas Nicklas]
+
+### Fixed
+
+* CSSHandlers now derives from BasicObject so globally included functions (concat, etc) shouldn't cause issues [Thomas Walpole]
+* touched reset after session is reset [lesliepc16]
+
+# Version 2.2.1
+
+Release date: 2014-01-06
+
+### Fixed
+
+* Reverted a change in 2.2.0 which navigates to an empty file on `reset`.
+  Capybara, now visits `about:blank` like it did before. [Jonas Nicklas]
+
 # Version 2.2.0
 
 Release date: 2013-11-21

data/README.md

@@ -23,10 +23,11 @@ GitHub): http://groups.google.com/group/ruby-capybara
 
 ## Setup
 
-Capybara requires Ruby 1.9.3 or later. To install, type:
+Capybara requires Ruby 1.9.3 or later. To install, add this line to your
+`Gemfile` and run `bundle install`:
 
-```bash
-gem install capybara
+```ruby
+gem 'capybara'
 ```
 
 If the application that you are testing is a Rails app, add this line to your test helper file:
@@ -342,7 +343,7 @@ You can get the [current path](http://rubydoc.info/github/jnicklas/capybara/mast
 of the browsing session for test assertions:
 
 ```ruby
-current_path.should == post_comments_path(post)
+expect(current_path).to eq(post_comments_path(post))
 ```
 
 ### Clicking links and buttons
@@ -399,12 +400,12 @@ has_selector?`. Read the section on asynchronous JavaScript for an explanation.
 You can use these with RSpec's magic matchers:
 
 ```ruby
-page.should have_selector('table tr')
-page.should have_selector(:xpath, '//table/tr')
+expect(page).to have_selector('table tr')
+expect(page).to have_selector(:xpath, '//table/tr')
 
-page.should have_xpath('//table/tr')
-page.should have_css('table tr.foo')
-page.should have_content('foo')
+expect(page).to have_xpath('//table/tr')
+expect(page).to have_css('table tr.foo')
+expect(page).to have_content('foo')
 ```
 
 ### Finding
@@ -431,7 +432,7 @@ to specific parts of the page:
 
 ```ruby
 find('#navigation').click_link('Home')
-find('#navigation').should have_button('Sign out')
+expect(find('#navigation')).to have_button('Sign out')
 ```
 
 ### Scoping
@@ -466,6 +467,21 @@ within_table('Employee') do
 end
 ```
 
+### Working with windows
+
+Capybara provides some methods to ease finding and switching windows:
+
+```ruby
+facebook_window = window_opened_by do
+  click_button 'Like'
+end
+within_window facebook_window do
+  find('#login_email').set('a@example.com')
+  find('#login_password').set('qwerty')
+  click_button 'Submit'
+end
+```
+
 ### Scripting
 
 In drivers which support it, you can easily execute JavaScript:
@@ -506,6 +522,12 @@ Finally, in drivers that support it, you can save a screenshot:
 page.save_screenshot('screenshot.png')
 ```
 
+Or have it save and automatically open:
+
+```ruby
+save_and_open_screenshot
+```
+
 ## Matching
 
 It is possible to customize how Capybara finds elements. At your disposal
@@ -594,7 +616,7 @@ When issuing instructions to the DSL such as:
 ```ruby
 click_link('foo')
 click_link('bar')
-page.should have_content('baz')
+expect(page).to have_content('baz')
 ```
 
 If clicking on the *foo* link triggers an asynchronous process, such as
@@ -626,15 +648,15 @@ Capybara's Rspec matchers, however, are smart enough to handle either form.
 The two following statements are functionally equivalent:
 
 ```ruby
-page.should_not have_xpath('a')
-page.should have_no_xpath('a')
+expect(page).not_to have_xpath('a')
+expect(page).to have_no_xpath('a')
 ```
 
 Capybara's waiting behaviour is quite advanced, and can deal with situations
 such as the following line of code:
 
 ```ruby
-find('#sidebar').find('h1').should have_content('Something')
+expect(find('#sidebar').find('h1')).to have_content('Something')
 ```
 
 Even if JavaScript causes `#sidebar` to disappear off the page, Capybara

data/lib/capybara.rb

@@ -13,6 +13,8 @@ module Capybara
   class UnselectNotAllowed < CapybaraError; end
   class NotSupportedByDriverError < CapybaraError; end
   class InfiniteRedirectError < CapybaraError; end
+  class ScopeError < CapybaraError; end
+  class WindowError < CapybaraError; end
 
   class << self
     attr_accessor :asset_host, :app_host, :run_server, :default_host, :always_include_port
@@ -39,7 +41,7 @@ module Capybara
     # [run_server = Boolean]              Whether to start a Rack server for the given Rack app (Default: true)
     # [default_selector = :css/:xpath]    Methods which take a selector use the given type by default (Default: CSS)
     # [default_wait_time = Integer]       The number of seconds to wait for asynchronous processes to finish (Default: 2)
-    # [ignore_hidden_elements = Boolean]  Whether to ignore hidden elements on the page (Default: false)
+    # [ignore_hidden_elements = Boolean]  Whether to ignore hidden elements on the page (Default: true)
     # [automatic_reload = Boolean]        Whether to automatically reload elements as Capybara is waiting (Default: true)
     # [save_and_open_page_path = String]  Where to put pages saved through save_and_open_page (Default: Dir.pwd)
     #
@@ -86,7 +88,7 @@ module Capybara
     #     find(:row, 3)
     #     page.find('table#myTable').find(:row, 3).text
     #     page.find('table#myTable').has_selector?(:row, 3)
-    #     within(:row, 3) { page.should have_content('$100.000') }
+    #     within(:row, 3) { expect(page).to have_content('$100.000') }
     #
     # Here is another example:
     #
@@ -118,7 +120,7 @@ module Capybara
     #
     # By default, Capybara will try to run webrick.
     #
-    # @yield [app, port]                      This block recieves a rack app and port and should run a Rack handler
+    # @yield [app, port]                      This block receives a rack app and port and should run a Rack handler
     #
     def server(&block)
       if block_given?
@@ -316,6 +318,7 @@ module Capybara
   require 'capybara/helpers'
   require 'capybara/session'
   require 'capybara/dsl'
+  require 'capybara/window'
   require 'capybara/server'
   require 'capybara/selector'
   require 'capybara/query'

data/lib/capybara/driver/base.rb

@@ -51,10 +51,46 @@ class Capybara::Driver::Base
     raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#within_frame'
   end
 
-  def within_window(handle)
+  def current_window_handle
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#current_window_handle'
+  end
+
+  def window_size(handle)
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#window_size'
+  end
+
+  def resize_window_to(handle, width, height)
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#resize_window_to'
+  end
+
+  def maximize_window(handle)
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#maximize_current_window'
+  end
+
+  def close_window(handle)
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#close_window'
+  end
+
+  def window_handles
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#window_handles'
+  end
+
+  def open_new_window
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#open_new_window'
+  end
+
+  def switch_to_window(handle)
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#switch_to_window'
+  end
+
+  def within_window(locator)
     raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#within_window'
   end
 
+  def no_such_window_error
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#no_such_window_error'
+  end
+
   def invalid_element_errors
     []
   end

data/lib/capybara/driver/node.rb

@@ -40,7 +40,15 @@ module Capybara
       def click
         raise NotImplementedError
       end
-
+      
+      def right_click
+        raise NotImplmentedError
+      end
+      
+      def double_click
+        raise NotImplementedError
+      end
+      
       def hover
         raise NotImplementedError
       end
@@ -79,7 +87,7 @@ module Capybara
 
       def inspect
         %(#<#{self.class} tag="#{tag_name}" path="#{path}">)
-      rescue NotSupportedByDriverError, 'Capybara::Driver::Node#inspect'
+      rescue NotSupportedByDriverError
         %(#<#{self.class} tag="#{tag_name}">)
       end
 

data/lib/capybara/helpers.rb

@@ -51,8 +51,10 @@ module Capybara
 
     ##
     #
-    # Checks if the given count matches the given count options. By default,
-    # when no options are given, count should be larger than zero.
+    # Checks if the given count matches the given count options.
+    # Defaults to true if no options are specified. If multiple
+    # options are provided, it tests that all conditions are met;
+    # however, if :count is supplied, all other options are ignored.
     #
     # @param [Integer] count     The actual number. Should be coercible via Integer()
     # @option [Range] between    Count must be within the given range
@@ -61,17 +63,23 @@ module Capybara
     # @option [Integer] minimum  Count must be larger than or equal to this value
     #
     def matches_count?(count, options={})
-      case
-      when options[:between]
-        options[:between] === count
-      when options[:count]
-        Integer(options[:count]) == count
-      when options[:maximum]
-        Integer(options[:maximum]) >= count
-      when options[:minimum]
-        Integer(options[:minimum]) <= count
+      return (Integer(options[:count]) == count)     if options[:count]
+      return false if options[:maximum] && (Integer(options[:maximum]) < count)
+      return false if options[:minimum] && (Integer(options[:minimum]) > count)
+      return false if options[:between] && !(options[:between] === count)
+      return true
+    end
+
+    ##
+    #
+    # Checks if a count of 0 is valid for the given options hash.
+    # Returns false if options hash does not specify any count options.
+    #
+    def expects_none?(options={})
+      if [:count, :maximum, :minimum, :between].any? { |k| options.has_key? k }
+        matches_count?(0,options)
       else
-        count > 0
+        false
       end
     end
 
@@ -104,7 +112,7 @@ module Capybara
     #
     # A poor man's `pluralize`. Given two declensions, one singular and one
     # plural, as well as a count, this will pick the correct declension. This
-    # way we can generate gramatically correct error message.
+    # way we can generate grammatically correct error message.
     #
     # @param [String] singular     The singular form of the word
     # @param [String] plural       The plural form of the word

data/lib/capybara/node/base.rb

@@ -40,14 +40,14 @@ module Capybara
 
       ##
       #
-      # This method is Capybara's primary defence agains asynchronicity
+      # This method is Capybara's primary defence against 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
+      # Certain drivers, such as RackTest, have no support for asynchronous
       # 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.
@@ -61,16 +61,19 @@ module Capybara
       #
       # 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`
+      # {Capybara.default_wait_time} and can be overridden 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
+      # @param options [Hash]
+      # @option options [Array<Exception>] :errors (driver.invalid_element_errors +
+      #   [Capybara::ElementNotFound]) exception types that cause the block to be rerun
       # @return [Object]                  The result of the given block
       # @raise  [Capybara::FrozenInTime]  If the return value of `Time.now` appears stuck
       #
-      def synchronize(seconds=Capybara.default_wait_time)
+      def synchronize(seconds=Capybara.default_wait_time, options = {})
         start_time = Time.now
 
         if session.synchronized
@@ -80,8 +83,9 @@ module Capybara
           begin
             yield
           rescue => e
+            session.raise_server_error!
             raise e unless driver.wait?
-            raise e unless catch_error?(e)
+            raise e unless catch_error?(e, options[:errors])
             raise e if (Time.now - start_time) >= seconds
             sleep(0.05)
             raise Capybara::FrozenInTime, "time appears to be frozen, Capybara does not work with libraries which freeze time, consider using time travelling instead" if Time.now == start_time
@@ -95,8 +99,9 @@ module Capybara
 
     protected
 
-      def catch_error?(error)
-        (driver.invalid_element_errors + [Capybara::ElementNotFound]).any? do |type|
+      def catch_error?(error, errors = nil)
+        errors ||= (driver.invalid_element_errors + [Capybara::ElementNotFound])
+        errors.any? do |type|
           error.is_a?(type)
         end
       end

data/lib/capybara/node/element.rb

@@ -118,6 +118,22 @@ module Capybara
         synchronize { base.click }
       end
 
+      ##
+      #
+      # Right Click the Element
+      #
+      def right_click
+        synchronize { base.right_click }
+      end
+
+      ##
+      #
+      # Double Click the Element
+      #
+      def double_click
+        synchronize { base.double_click }
+      end
+
       ##
       #
       # Hover on the Element
@@ -224,7 +240,7 @@ module Capybara
 
       def inspect
         %(#<Capybara::Element tag="#{tag_name}" path="#{path}">)
-      rescue NotSupportedByDriverError, 'Capybara::Node::Element#inspect'
+      rescue NotSupportedByDriverError
         %(#<Capybara::Element tag="#{tag_name}">)
       end
     end

data/lib/capybara/node/finders.rb

@@ -116,17 +116,38 @@ module Capybara
       #     page.all('a', :text => 'Home')
       #     page.all('#menu li', :visible => true)
       #
+      # By default if no elements are found, an empty array is returned;
+      # however, expectations can be set on the number of elements to be
+      # found using:
+      #
+      #     page.assert_selector('p#foo', :count => 4)
+      #     page.assert_selector('p#foo', :maximum => 10)
+      #     page.assert_selector('p#foo', :minimum => 1)
+      #     page.assert_selector('p#foo', :between => 1..10)
+      #
+      # See {Capybara::Helpers#matches_count?} for additional information about
+      # count matching.
+      #
       # @overload all([kind], locator, options)
       #   @param [:css, :xpath] kind                 The type of selector
       #   @param [String] locator                    The selector
       #   @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
       #   @option options [Boolean] visible          Only find elements that are visible on the page. Setting this to false
       #                                              finds invisible _and_ visible elements.
+      #   @option options [Integer] count            Exact number of matches that are expected to be found
+      #   @option options [Integer] maximum          Maximum number of matches that are expected to be found
+      #   @option options [Integer] minimum          Minimum number of matches that are expected to be found
+      #   @option options [Range]   between          Number of matches found must be within the given range
       #   @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially
       # @return [Capybara::Result]                   A collection of found elements
       #
       def all(*args)
-        resolve_query(Capybara::Query.new(*args))
+        query = Capybara::Query.new(*args)
+        synchronize(query.wait) do
+          result = resolve_query(query)
+          raise(Capybara::ExpectationNotMet, result.failure_message) unless result.matches_count?
+          result
+        end
       end
 
       ##