capybara 2.2.1 → 2.3.0

data/lib/capybara/node/matchers.rb

@@ -68,7 +68,11 @@ module Capybara
       #
       #     page.assert_selector('p#foo', :count => 4)
       #
-      # This will check if the expression occurs exactly 4 times.
+      # This will check if the expression occurs exactly 4 times. See
+      # {Capybara::Node::Finders#all} for other available result size options.
+      #
+      # If a :count of 0 is specified, it will behave like {#assert_no_selector};
+      # however, use of that method is preferred over this one.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
@@ -88,7 +92,7 @@ module Capybara
         query = Capybara::Query.new(*args)
         synchronize(query.wait) do
           result = all(*args)
-          result.matches_count? or raise Capybara::ExpectationNotMet, result.failure_message
+          raise Capybara::ExpectationNotMet, result.failure_message if result.size == 0 && !Capybara::Helpers.expects_none?(query.options)
         end
         return true
       end
@@ -98,18 +102,35 @@ module Capybara
       # Asserts that a given selector is not on the page or current node.
       # Usage is identical to Capybara::Node::Matchers#assert_selector
       #
+      # Query options such as :count, :minimum, :maximum, and :between are
+      # considered to be an integral part of the selector. This will return
+      # true, for example, if a page contains 4 anchors but the query expects 5:
+      #
+      #     page.assert_no_selector('a', :minimum => 1) # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', :count => 4)   # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', :count => 5)   # Not Found, returns true
+      #
       # @param (see Capybara::Node::Finders#assert_selector)
       # @raise [Capybara::ExpectationNotMet]      If the selector exists
       #
       def assert_no_selector(*args)
         query = Capybara::Query.new(*args)
         synchronize(query.wait) do
-          result = all(*args)
-          result.matches_count? and raise Capybara::ExpectationNotMet, result.negative_failure_message
+          begin
+            result = all(*args)
+          rescue Capybara::ExpectationNotMet => e
+            return true
+          else
+            if result.size > 0 || (result.size == 0 && Capybara::Helpers.expects_none?(query.options))
+              raise(Capybara::ExpectationNotMet, result.negative_failure_message)
+            end
+          end
         end
         return true
       end
 
+      alias_method :refute_selector, :assert_no_selector
+
       ##
       #
       # Checks if a given XPath expression is on the page or current node.
@@ -469,7 +490,7 @@ module Capybara
         content, options = args
         count = Capybara::Helpers.normalize_whitespace(text(type)).scan(Capybara::Helpers.to_regexp(content)).count
 
-        Capybara::Helpers.matches_count?(count, options || {})
+        Capybara::Helpers.matches_count?(count, {:minimum=>1}.merge(options || {}))
       end
     end
   end

data/lib/capybara/node/simple.rb

@@ -94,10 +94,17 @@ module Capybara
       # Whether or not the element is visible. Does not support CSS, so
       # the result may be inaccurate.
       #
+      # @param  [Boolean] check_ancestors  Whether to inherit visibility from ancestors
       # @return [Boolean]     Whether the element is visible
       #
-      def visible?
-        native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head']").size == 0
+      def visible?(check_ancestors = true)
+        if check_ancestors
+          #check size because oldest supported nokogiri doesnt support xpath boolean() function
+          native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head']").size() == 0
+        else
+          #no need for an xpath if only checking the current element
+          !(native.has_attribute?('hidden') || (native[:style] =~ /display:\s?none/) || %w(script head).include?(tag_name))
+        end
       end
 
       ##

data/lib/capybara/rack_test/css_handlers.rb

@@ -1,4 +1,6 @@
-class Capybara::RackTest::CSSHandlers
+class Capybara::RackTest::CSSHandlers < BasicObject
+  include ::Kernel
+  
   def disabled list
     list.find_all { |node| node.has_attribute? 'disabled' }
   end        

data/lib/capybara/rack_test/form.rb

@@ -1,6 +1,6 @@
 class Capybara::RackTest::Form < Capybara::RackTest::Node
   # This only needs to inherit from Rack::Test::UploadedFile because Rack::Test checks for
-  # the class specifically when determing whether to consturct the request as multipart.
+  # the class specifically when determining whether to construct the request as multipart.
   # That check should be based solely on the form element's 'enctype' attribute value,
   # which should probably be provided to Rack::Test in its non-GET request methods.
   class NilUploadedFile < Rack::Test::UploadedFile
@@ -71,7 +71,8 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
   end
 
   def submit(button)
-    driver.submit(method, native['action'].to_s, params(button))
+    action = (button && button['formaction']) || native['action']
+    driver.submit(method, action.to_s, params(button))
   end
 
   def multipart?

data/lib/capybara/rack_test/node.rb

@@ -99,14 +99,14 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
 
 protected
 
-  def unnormalized_text
-    if !visible?
+  def unnormalized_text(check_ancestor_visibility = true)
+    if !string_node.visible?(check_ancestor_visibility)
       ''
     elsif native.text?
       native.text
     elsif native.element?
       native.children.map do |child|
-        Capybara::RackTest::Node.new(driver, child).unnormalized_text
+        Capybara::RackTest::Node.new(driver, child).unnormalized_text(false)
       end.join
     else
       ''

data/lib/capybara/rspec.rb

@@ -29,3 +29,4 @@ RSpec.configure do |config|
     end
   end
 end
+

data/lib/capybara/rspec/features.rb

@@ -21,7 +21,8 @@ def self.feature(*args, &block)
   options[:caller] ||= caller
   args.push(options)
 
-  describe(*args, &block)
+  #call describe on RSpec in case user has expose_dsl_globally set to false
+  RSpec.describe(*args, &block)
 end
 
 RSpec.configuration.include Capybara::Features, :capybara_feature => true

data/lib/capybara/rspec/matchers.rb

@@ -51,16 +51,20 @@ module Capybara
         @actual.has_no_text?(type, content, options)
       end
 
-      def failure_message_for_should
+      def failure_message
         message = Capybara::Helpers.failure_message(description, options)
         message << " in #{format(@actual.text(type))}"
         message
       end
 
-      def failure_message_for_should_not
-        failure_message_for_should.sub(/(to find)/, 'not \1')
+      def failure_message_when_negated
+        failure_message.sub(/(to find)/, 'not \1')
       end
 
+      # RSpec 2 compatibility:
+      alias_method :failure_message_for_should, :failure_message
+      alias_method :failure_message_for_should_not, :failure_message_when_negated
+
       def description
         "text #{format(content)}"
       end
@@ -88,19 +92,50 @@ module Capybara
         @actual.has_no_title?(title)
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected there to be title #{title.inspect} in #{@actual.title.inspect}"
       end
 
-      def failure_message_for_should_not
+      def failure_message_when_negated
         "expected there not to be title #{title.inspect} in #{@actual.title.inspect}"
       end
 
+      # RSpec 2 compatibility:
+      alias_method :failure_message_for_should, :failure_message
+      alias_method :failure_message_for_should_not, :failure_message_when_negated
+
       def description
         "have title #{title.inspect}"
       end
     end
 
+    class BecomeClosed
+      def initialize(options)
+        @wait_time = Capybara::Query.new(options).wait
+      end
+
+      def matches?(window)
+        @window = window
+        start_time = Time.now
+        while window.exists? && (Time.now - start_time) < @wait_time
+          sleep 0.05
+        end
+        window.closed?
+      end
+
+      def failure_message
+        "expected #{@window.inspect} to become closed after #{@wait_time} seconds"
+      end
+
+      def failure_message_when_negated
+        "expected #{@window.inspect} not to become closed after #{@wait_time} seconds"
+      end
+
+      # RSpec 2 compatibility:
+      alias_method :failure_message_for_should, :failure_message
+      alias_method :failure_message_for_should_not, :failure_message_when_negated
+    end
+
     def have_selector(*args)
       HaveSelector.new(*args)
     end
@@ -149,5 +184,15 @@ module Capybara
     def have_table(locator, options={})
       HaveSelector.new(:table, locator, options)
     end
+
+    ##
+    # Wait for window to become closed.
+    # @example
+    #   expect(window).to become_closed(wait: 0.8)
+    # @param options [Hash] optional param
+    # @option options [Numeric] :wait (Capybara.default_wait_time) wait time
+    def become_closed(options = {})
+      BecomeClosed.new(options)
+    end
   end
 end

data/lib/capybara/selenium/driver.rb

@@ -126,34 +126,98 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     @frame_handles[browser.window_handle].each { |fh| browser.switch_to.frame(fh) }
   end
 
-  def find_window( selector )
+  def current_window_handle
+    browser.window_handle
+  end
+
+  def window_size(handle)
+    within_given_window(handle) do
+      size = browser.manage.window.size
+      [size.width, size.height]
+    end
+  end
+
+  def resize_window_to(handle, width, height)
+    within_given_window(handle) do
+      browser.manage.window.resize_to(width, height)
+    end
+  end
+
+  def maximize_window(handle)
+    within_given_window(handle) do
+      browser.manage.window.maximize
+    end
+    sleep 0.1 # work around for https://code.google.com/p/selenium/issues/detail?id=7405
+  end
+
+  def close_window(handle)
+    within_given_window(handle) do
+      browser.close
+    end
+  end
+
+  def window_handles
+    browser.window_handles
+  end
+
+  def open_new_window
+    browser.execute_script('window.open();')
+  end
+
+  def switch_to_window(handle)
+    browser.switch_to.window handle
+  end
+
+  # @api private
+  def find_window(locator)
+    handles = browser.window_handles
+    return locator if handles.include? locator
+
     original_handle = browser.window_handle
-    browser.window_handles.each do |handle|
-      browser.switch_to.window handle
-      if( selector == browser.execute_script("return window.name") ||
-          browser.title.include?(selector) ||
-          browser.current_url.include?(selector) ||
-          (selector == handle) )
-        browser.switch_to.window original_handle
+    handles.each do |handle|
+      switch_to_window(handle)
+      if (locator == browser.execute_script("return window.name") ||
+          browser.title.include?(locator) ||
+          browser.current_url.include?(locator))
+        switch_to_window(original_handle)
         return handle
       end
     end
-    raise Capybara::ElementNotFound, "Could not find a window identified by #{selector}"
+    raise Capybara::ElementNotFound, "Could not find a window identified by #{locator}"
   end
 
-  def within_window(selector, &blk)
-    handle = find_window( selector )
-    browser.switch_to.window(handle, &blk)
+  def within_window(locator)
+    handle = find_window(locator)
+    browser.switch_to.window(handle) { yield }
   end
 
   def quit
     @browser.quit if @browser
   rescue Errno::ECONNREFUSED
     # Browser must have already gone
+  ensure
+    @browser = nil
   end
 
   def invalid_element_errors
     [Selenium::WebDriver::Error::StaleElementReferenceError, Selenium::WebDriver::Error::UnhandledError, Selenium::WebDriver::Error::ElementNotVisibleError]
   end
 
+  def no_such_window_error
+    Selenium::WebDriver::Error::NoSuchWindowError
+  end
+
+  private
+
+  def within_given_window(handle)
+    original_handle = self.current_window_handle
+    if handle == original_handle
+      yield
+    else
+      switch_to_window(handle)
+      result = yield
+      switch_to_window(original_handle)
+      result
+    end
+  end
 end

data/lib/capybara/selenium/node.rb

@@ -70,6 +70,14 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   def click
     native.click
   end
+  
+  def right_click
+    driver.browser.action.context_click(native).perform
+  end
+  
+  def double_click
+    driver.browser.action.double_click(native).perform
+  end
 
   def hover
     driver.browser.action.move_to(native).perform

data/lib/capybara/server.rb

@@ -36,7 +36,7 @@ module Capybara
     def initialize(app, port=Capybara.server_port, host=Capybara.server_host)
       @app = app
       @middleware = Middleware.new(@app)
-      @server_thread = nil # supress warnings
+      @server_thread = nil # suppress warnings
       @host, @port = host, port
       @port ||= Capybara::Server.ports[@app.object_id]
       @port ||= find_available_port

data/lib/capybara/session.rb

@@ -19,7 +19,7 @@ module Capybara
   #
   #     session.fill_in('q', :with => 'Capybara')
   #     session.click_button('Search')
-  #     session.should have_content('Capybara')
+  #     expect(session).to have_content('Capybara')
   #
   # When using capybara/dsl, the Session is initialized automatically for you.
   #
@@ -34,15 +34,17 @@ module Capybara
       :has_no_field?, :has_checked_field?, :has_unchecked_field?,
       :has_no_table?, :has_table?, :unselect, :has_select?, :has_no_select?,
       :has_selector?, :has_no_selector?, :click_on, :has_no_checked_field?,
-      :has_no_unchecked_field?, :query, :assert_selector, :assert_no_selector
+      :has_no_unchecked_field?, :query, :assert_selector, :assert_no_selector,
+      :refute_selector
     ]
     SESSION_METHODS = [
       :body, :html, :source, :current_url, :current_host, :current_path,
       :execute_script, :evaluate_script, :visit, :go_back, :go_forward,
-      :within, :within_fieldset, :within_table, :within_frame, :within_window,
+      :within, :within_fieldset, :within_table, :within_frame, :current_window,
+      :windows, :open_new_window, :switch_to_window, :within_window, :window_opened_by,
       :save_page, :save_and_open_page, :save_screenshot,
-      :reset_session!, :response_headers, :status_code,
-      :title, :has_title?, :has_no_title?, :current_scope
+      :save_and_open_screenshot, :reset_session!, :response_headers,
+      :status_code, :title, :has_title?, :has_no_title?, :current_scope
     ]
     DSL_METHODS = NODE_METHODS + SESSION_METHODS
 
@@ -72,20 +74,42 @@ module Capybara
 
     ##
     #
-    # Reset the session, removing all cookies.
+    # Reset the session (i.e. remove cookies and navigate to blank page)
+    #
+    # This method does not:
+    #
+    #   * accept modal dialogs if they are present
+    #   * clear browser cache/HTML 5 local storage/IndexedDB/Web SQL database/etc.
+    #   * modify state of the driver/underlying browser in any other way
+    #
+    # as doing so will result in performance downsides and it's not needed to do everything from the list above for most apps.
+    #
+    # If you want to do anything from the list above on a general basis you can:
+    #
+    #   * write RSpec/Cucumber/etc. after hook
+    #   * monkeypatch this method
+    #   * use Ruby's `prepend` method
     #
     def reset!
       if @touched
         driver.reset!
-        @touched = false
         assert_no_selector :xpath, "/html/body/*"
+        @touched = false
       end
+      raise_server_error!
+    end
+    alias_method :cleanup!, :reset!
+    alias_method :reset_session!, :reset!
+
+    ##
+    #
+    # Raise errors encountered in the server
+    #
+    def raise_server_error!
       raise @server.error if Capybara.raise_server_errors and @server and @server.error
     ensure
       @server.reset_error! if @server
     end
-    alias_method :cleanup!, :reset!
-    alias_method :reset_session!, :reset!
 
     ##
     #
@@ -178,6 +202,8 @@ module Capybara
     # @param [String] url     The URL to navigate to
     #
     def visit(url)
+      raise_server_error!
+
       @touched = true
 
       if url !~ /^http/ and Capybara.app_host
@@ -302,17 +328,172 @@ module Capybara
     end
 
     ##
+    # @return [Capybara::Window]   current window
     #
-    # Execute the given block within the given window. Only works on
-    # some drivers (e.g. Selenium)
+    def current_window
+      Window.new(self, driver.current_window_handle)
+    end
+
+    ##
+    # Get all opened windows.
+    # The order of windows in returned array is not defined.
+    # The driver may sort windows by their creation time but it's not required.
     #
-    # @param [String] handle of the window
+    # @return [Array<Capybara::Window>]   an array of all windows
     #
-    def within_window(handle, &blk)
-      scopes.push(nil)
-      driver.within_window(handle, &blk)
-    ensure
-      scopes.pop
+    def windows
+      driver.window_handles.map do |handle|
+        Window.new(self, handle)
+      end
+    end
+
+    ##
+    # Open new window.
+    # Current window doesn't change as the result of this call.
+    # It should be switched to explicitly.
+    #
+    # @return [Capybara::Window]   window that has been opened
+    #
+    def open_new_window
+      window_opened_by do
+        driver.open_new_window
+      end
+    end
+
+    ##
+    # @overload switch_to_window(&block)
+    #   Switches to the first window for which given block returns a value other than false or nil.
+    #   If window that matches block can't be found, the window will be switched back and `WindowError` will be raised.
+    #   @example
+    #     window = switch_to_window { title == 'Page title' }
+    #   @raise [Capybara::WindowError]     if no window matches given block
+    # @overload switch_to_window(window)
+    #   @param window [Capybara::Window]   window that should be switched to
+    #   @raise [Capybara::Driver::Base#no_such_window_error] if unexistent (e.g. closed) window was passed
+    #
+    # @return [Capybara::Window]         window that has been switched to
+    # @raise [Capybara::ScopeError]        if this method is invoked inside `within`,
+    #   `within_frame` or `within_window` methods
+    # @raise [ArgumentError]               if both or neither arguments were provided
+    #
+    def switch_to_window(window = nil)
+      block_given = block_given?
+      if window && block_given
+        raise ArgumentError, "`switch_to_window` can take either a block or a window, not both"
+      elsif !window && !block_given
+        raise ArgumentError, "`switch_to_window`: either window or block should be provided"
+      elsif scopes.size > 1
+        raise Capybara::ScopeError, "`switch_to_window` is not supposed to be invoked from "\
+                                    "`within`'s, `within_frame`'s' or `within_window`'s' block."
+      end
+
+      if window
+        driver.switch_to_window(window.handle)
+        window
+      else
+        original_window_handle = driver.current_window_handle
+        begin
+          driver.window_handles.each do |handle|
+            driver.switch_to_window handle
+            if yield
+              return Window.new(self, handle)
+            end
+          end
+        rescue => e
+          driver.switch_to_window(original_window_handle)
+          raise e
+        else
+          driver.switch_to_window(original_window_handle)
+          raise Capybara::WindowError, "Could not find a window matching block/lambda"
+        end
+      end
+    end
+
+    ##
+    # This method does the following:
+    #
+    # 1. Switches to the given window (it can be located by window instance/lambda/string).
+    # 2. Executes the given block (within window located at previous step).
+    # 3. Switches back (this step will be invoked even if exception will happen at second step)
+    #
+    # @overload within_window(window) { do_something }
+    #   @param window [Capybara::Window]       instance of `Capybara::Window` class
+    #     that will be switched to
+    #   @raise [driver#no_such_window_error] if unexistent (e.g. closed) window was passed
+    # @overload within_window(proc_or_lambda) { do_something }
+    #   @param lambda [Proc]                  lambda. First window for which lambda
+    #     returns a value other than false or nil will be switched to.
+    #   @example
+    #     within_window(->{ page.title == 'Page title' }) { click_button 'Submit' }
+    #   @raise [Capybara::WindowError]         if no window matching lambda was found
+    # @overload within_window(string) { do_something }
+    #   @deprecated                            Pass window or lambda instead
+    #   @param [String]                        handle, name, url or title of the window
+    #
+    # @raise [Capybara::ScopeError]        if this method is invoked inside `within`,
+    #   `within_frame` or `within_window` methods
+    # @return                              value returned by the block
+    #
+    def within_window(window_or_handle)
+      if window_or_handle.instance_of?(Capybara::Window)
+        original = current_window
+        switch_to_window(window_or_handle) unless original == window_or_handle
+        scopes << nil
+        begin
+          yield
+        ensure
+          @scopes.pop
+          switch_to_window(original) unless original == window_or_handle
+        end
+      elsif window_or_handle.is_a?(Proc)
+        original = current_window
+        switch_to_window { window_or_handle.call }
+        scopes << nil
+        begin
+          yield
+        ensure
+          @scopes.pop
+          switch_to_window(original)
+        end
+      else
+        offending_line = caller.first
+        file_line = offending_line.match(/^(.+?):(\d+)/)[0]
+        warn "DEPRECATION WARNING: Passing string argument to #within_window is deprecated. "\
+             "Pass window object or lambda. (called from #{file_line})"
+        begin
+          scopes << nil
+          driver.within_window(window_or_handle) { yield }
+        ensure
+          @scopes.pop
+        end
+      end
+    end
+
+    ##
+    # Get the window that has been opened by the passed block.
+    # It will wait for it to be opened (in the same way as other Capybara methods wait).
+    # It's better to use this method than `windows.last`
+    # {https://dvcs.w3.org/hg/webdriver/raw-file/default/webdriver-spec.html#h_note_10 as order of windows isn't defined in some drivers}
+    #
+    # @param options [Hash]
+    # @option options [Numeric] :wait (Capybara.default_wait_time) wait time
+    # @return [Capybara::Window]       the window that has been opened within a block
+    # @raise [Capybara::WindowError]   if block passed to window hasn't opened window
+    #   or opened more than one window
+    #
+    def window_opened_by(options = {}, &block)
+      old_handles = driver.window_handles
+      block.call
+
+      wait_time = Capybara::Query.new(options).wait
+      document.synchronize(wait_time, errors: [Capybara::WindowError]) do
+        opened_handles = (driver.window_handles - old_handles)
+        if opened_handles.size != 1
+          raise Capybara::WindowError, "block passed to #window_opened_by "\
+                                       "opened #{opened_handles.size} windows instead of 1"
+        end
+        Window.new(self, opened_handles.first)
+      end
     end
 
     ##
@@ -349,12 +530,11 @@ module Capybara
     # @param  [String] path     The path to where it should be saved [optional]
     #
     def save_page(path=nil)
-      path ||= "capybara-#{Time.new.strftime("%Y%m%d%H%M%S")}#{rand(10**10)}.html"
-      path = File.expand_path(path, Capybara.save_and_open_page_path)
+      path ||= default_path('html')
 
       FileUtils.mkdir_p(File.dirname(path))
 
-      File.open(path,'w') { |f| f.write(Capybara::Helpers.inject_asset_host(body)) }
+      File.open(path,'wb') { |f| f.write(Capybara::Helpers.inject_asset_host(body)) }
       path
     end
 
@@ -366,14 +546,7 @@ module Capybara
     #
     def save_and_open_page(file_name=nil)
       file_name = save_page(file_name)
-
-      begin
-        require "launchy"
-        Launchy.open(file_name)
-      rescue LoadError
-        warn "Page saved to #{file_name} with save_and_open_page."
-        warn "Please install the launchy gem to open page automatically."
-      end
+      open_file(file_name)
     end
 
     ##
@@ -383,7 +556,23 @@ module Capybara
     # @param  [String] path    A string of image path
     # @option [Hash]   options Options for saving screenshot
     def save_screenshot(path, options={})
+      path ||= default_path('png')
+
+      FileUtils.mkdir_p(File.dirname(path))
+
       driver.save_screenshot(path, options)
+      path
+    end
+
+    ##
+    #
+    # Save a screenshot of the page and open it for inspection
+    #
+    # @param  [String] file_name  The path to where it should be saved [optional]
+    #
+    def save_and_open_screenshot(file_name=nil)
+      file_name = save_screenshot(file_name)
+      open_file(file_name)
     end
 
     def document
@@ -429,8 +618,24 @@ module Capybara
 
   private
 
+    def open_file(file_name)
+      begin
+        require "launchy"
+        Launchy.open(file_name)
+      rescue LoadError
+        warn "File saved to #{file_name}."
+        warn "Please install the launchy gem to open the file automatically."
+      end
+    end
+
+    def default_path(extension)
+      timestamp = Time.new.strftime("%Y%m%d%H%M%S")
+      path = "capybara-#{timestamp}#{rand(10**10)}.#{extension}"
+      File.expand_path(path, Capybara.save_and_open_page_path)
+    end
+
     def scopes
-      @scopes ||= [document]
+      @scopes ||= [nil]
     end
   end
 end