capybara 0.3.0 → 0.3.5

data/lib/capybara/dsl.rb

@@ -1,3 +1,5 @@
+require 'capybara'
+
 module Capybara
   class << self
     attr_writer :default_driver, :current_driver, :javascript_driver
@@ -30,6 +32,7 @@ module Capybara
     end
 
     def reset_sessions!
+      session_pool.each { |mode, session| session.cleanup! }
       @session_pool = nil
     end
 
@@ -46,16 +49,7 @@ module Capybara
     Capybara.current_session
   end
 
-  SESSION_METHODS = [
-    :visit, :current_url, :body, :click_link, :click_button, :drag, :fill_in,
-    :choose, :has_xpath?, :has_no_xpath?, :has_css?, :has_no_css?,
-    :check, :uncheck, :attach_file, :select, :source,
-    :has_content?, :has_no_content?, :within, :within_fieldset, :within_table,
-    :save_and_open_page, :find, :find_field, :find_link, :find_button,
-    :field_labeled, :all, :locate, :evaluate_script,
-    :click, :wait_until
-  ]
-  SESSION_METHODS.each do |method|
+  Session::DSL_METHODS.each do |method|
     class_eval <<-RUBY, __FILE__, __LINE__+1
       def #{method}(*args, &block)
         page.#{method}(*args, &block)

data/lib/capybara/node.rb

@@ -29,6 +29,10 @@ module Capybara
       raise NotImplementedError
     end
 
+    def unselect(option)
+      raise NotImplementedError
+    end
+
     def click
       raise NotImplementedError
     end
@@ -48,6 +52,10 @@ module Capybara
     def path
       raise NotSupportedByDriverError
     end
+    
+    def trigger(event)
+      raise NotSupportedByDriverError
+    end
 
     private
 

data/lib/capybara/rails.rb

@@ -3,9 +3,15 @@ require 'capybara/dsl'
 
 Capybara.app = Rack::Builder.new do
   map "/" do
-    use Rails::Rack::Static
-    run ActionController::Dispatcher.new
+    if Rails.version.to_f >= 3.0
+      ActionDispatch::Static
+      run Rails.application  
+    else # Rails 2
+      use Rails::Rack::Static
+      run ActionController::Dispatcher.new
+    end
   end
 end.to_app
 
 Capybara.asset_root = Rails.root.join('public')
+

data/lib/capybara/save_and_open_page.rb

@@ -23,7 +23,11 @@ module Capybara
 
     def rewrite_css_and_image_references(response_html) # :nodoc:
       return response_html unless Capybara.asset_root
-      response_html.gsub(/("|')\/(stylesheets|images|javascripts)/, '\1' + Capybara.asset_root + '/\2')
+      directories = Dir.new(Capybara.asset_root).entries.inject([]) do |list, name|
+        list << name if File.directory?(name) and not name.to_s =~ /^\./
+        list
+      end
+      response_html.gsub(/("|')\/(#{directories.join('|')})/, '\1' + Capybara.asset_root.to_s + '/\2')
     end
   end
 end

data/lib/capybara/searchable.rb

@@ -1,35 +1,43 @@
 module Capybara
   module Searchable
-    def find(locator, options = {})
-      all(locator, options).first
+    def find(*args)
+      all(*args).first
     end
 
     def find_field(locator)
-      find(XPath.field(locator))
+      find(:xpath, XPath.field(locator))
     end
     alias_method :field_labeled, :find_field
 
     def find_link(locator)
-      find(XPath.link(locator))
+      find(:xpath, XPath.link(locator))
     end
 
     def find_button(locator)
-      find(XPath.button(locator))
+      find(:xpath, XPath.button(locator))
     end
 
     def find_by_id(id)
-      find(Xpath.for_css("##{id}"))
+      find(:css, "##{id}")
     end
 
-    def all(locator, options = {})
+    def all(*args)
+      options = if args.last.is_a?(Hash) then args.pop else {} end
+      if args[1].nil?
+        kind, locator = Capybara.default_selector, args.first
+      else
+        kind, locator = args
+      end
+      locator = XPath.from_css(locator) if kind == :css
+
       results = all_unfiltered(locator)
 
       if options[:text]
         results = results.select { |n| n.text.match(options[:text]) }
       end
 
-      if options[:visible] == true
-        results.reject! { |n| !n.visible? }
+      if options[:visible] or Capybara.ignore_hidden_elements
+        results = results.select { |n| n.visible? }
       end
 
       results

data/lib/capybara/server.rb

@@ -1,11 +1,6 @@
 require 'uri'
 require 'net/http'
 require 'rack'
-begin
-  require 'rack/handler/mongrel'
-rescue LoadError
-  require 'rack/handler/webrick'
-end
 
 class Capybara::Server
   class Identify
@@ -26,49 +21,66 @@ class Capybara::Server
 
   def initialize(app)
     @app = app
-    find_available_port
-    boot
   end
 
   def host
-    'localhost'
+    "localhost" 
   end
 
   def url(path)
-    path = URI.parse(path).request_uri if path =~ /^http/
-    "http://#{host}:#{port}#{path}"
+    if path =~ /^http/
+      path
+    else
+      (Capybara.app_host || "http://#{host}:#{port}") + path.to_s
+    end
   end
 
   def responsive?
     is_running_on_port?(port)
   end
 
-private
+  def handler
+    begin
+      require 'rack/handler/thin'
+      Rack::Handler::Thin
+    rescue LoadError
+      begin
+        require 'rack/handler/mongrel'
+        Rack::Handler::Mongrel
+      rescue LoadError
+        require 'rack/handler/webrick'
+        Rack::Handler::WEBrick
+      end
+    end
+  end
 
   def boot
-    Capybara.log "application has already booted" and return if responsive?
+    find_available_port
+    Capybara.log "application has already booted" and return self if responsive?
     Capybara.log "booting Rack applicartion on port #{port}"
 
-    Timeout.timeout(10) do
-      Thread.new do
-        if defined?(Rack::Handler::Mongrel)
-          Rack::Handler::Mongrel.run(Identify.new(@app), :Port => port)
-        else
-          Rack::Handler::WEBrick.run(Identify.new(@app), :Port => port, :AccessLog => [])
-        end
-      end
-      Capybara.log "checking if application has booted"
+    Thread.new do
+      handler.run(Identify.new(@app), :Port => port, :AccessLog => [])
+    end
+    Capybara.log "checking if application has booted"
 
-      loop do
-        Capybara.log("application has booted") and break if responsive?
+    Capybara::WaitUntil.timeout(10) do
+      if responsive?
+        Capybara.log("application has booted")
+        true
+      else
         sleep 0.5
+        false
       end
     end
+    self
   rescue Timeout::Error
     Capybara.log "Rack application timed out during boot"
     exit
   end
 
+private
+
   def find_available_port
     @port = 9887
     @port += 1 while is_port_open?(@port) and not is_running_on_port?(@port)

data/lib/capybara/session.rb

@@ -4,6 +4,15 @@ module Capybara
   class Session
     include Searchable
 
+    DSL_METHODS = [
+      :all, :attach_file, :body, :check, :choose, :click, :click_button, :click_link, :current_url, :drag, :evaluate_script,
+      :field_labeled, :fill_in, :find, :find_button, :find_by_id, :find_field, :find_link, :has_content?, :has_css?,
+      :has_no_content?, :has_no_css?, :has_no_xpath?, :has_xpath?, :locate, :save_and_open_page, :select, :source, :uncheck,
+      :visit, :wait_until, :within, :within_fieldset, :within_table, :has_link?, :has_no_link?, :has_button?, :has_no_button?,
+      :has_field?, :has_no_field?, :has_checked_field?, :has_unchecked_field?, :has_no_table?, :has_table?, :unselect,
+      :has_select?, :has_no_select?
+    ]
+
     attr_reader :mode, :app
 
     def initialize(mode, app)
@@ -26,6 +35,10 @@ module Capybara
       end
     end
 
+    def cleanup!
+      driver.cleanup!
+    end
+
     def current_url
       driver.current_url
     end
@@ -40,53 +53,58 @@ module Capybara
 
     def click(locator)
       msg = "no link or button '#{locator}' found"
-      locate(XPath.link(locator).button(locator), msg).click
+      locate(:xpath, XPath.link(locator).button(locator), msg).click
     end
 
     def click_link(locator)
       msg = "no link with title, id or text '#{locator}' found"
-      locate(XPath.link(locator), msg).click
+      locate(:xpath, XPath.link(locator), msg).click
     end
 
     def click_button(locator)
       msg = "no button with value or id or text '#{locator}' found"
-      locate(XPath.button(locator)).click
+      locate(:xpath, XPath.button(locator), msg).click
     end
 
     def drag(source_locator, target_locator)
-      source = locate(source_locator, "drag source '#{source_locator}' not found on page")
-      target = locate(target_locator, "drag target '#{target_locator}' not found on page")
+      source = locate(:xpath, source_locator, "drag source '#{source_locator}' not found on page")
+      target = locate(:xpath, target_locator, "drag target '#{target_locator}' not found on page")
       source.drag_to(target)
     end
 
     def fill_in(locator, options={})
       msg = "cannot fill in, no text field, text area or password field with id, name, or label '#{locator}' found"
-      locate(XPath.fillable_field(locator), msg).set(options[:with])
+      locate(:xpath, XPath.fillable_field(locator), msg).set(options[:with])
     end
 
     def choose(locator)
       msg = "cannot choose field, no radio button with id, name, or label '#{locator}' found"
-      locate(XPath.radio_button(locator), msg).set(true)
+      locate(:xpath, XPath.radio_button(locator), msg).set(true)
     end
 
     def check(locator)
       msg = "cannot check field, no checkbox with id, name, or label '#{locator}' found"
-      locate(XPath.checkbox(locator), msg).set(true)
+      locate(:xpath, XPath.checkbox(locator), msg).set(true)
     end
 
     def uncheck(locator)
       msg = "cannot uncheck field, no checkbox with id, name, or label '#{locator}' found"
-      locate(XPath.checkbox(locator), msg).set(false)
+      locate(:xpath, XPath.checkbox(locator), msg).set(false)
     end
 
     def select(value, options={})
       msg = "cannot select option, no select box with id, name, or label '#{options[:from]}' found"
-      locate(XPath.select(options[:from]), msg).select(value)
+      locate(:xpath, XPath.select(options[:from]), msg).select(value)
+    end
+
+    def unselect(value, options={})
+      msg = "cannot unselect option, no select box with id, name, or label '#{options[:from]}' found"
+      locate(:xpath, XPath.select(options[:from]), msg).unselect(value)
     end
 
     def attach_file(locator, path)
       msg = "cannot attach file, no file field with id, name, or label '#{locator}' found"
-      locate(XPath.file_field(locator), msg).set(path)
+      locate(:xpath, XPath.file_field(locator), msg).set(path)
     end
 
     def body
@@ -100,27 +118,30 @@ module Capybara
     def within(kind, scope=nil)
       kind, scope = Capybara.default_selector, kind unless scope
       scope = XPath.from_css(scope) if kind == :css
-      locate(scope, "scope '#{scope}' not found on page")
-      scopes.push(scope)
-      yield
-      scopes.pop
+      locate(:xpath, scope, "scope '#{scope}' not found on page")
+      begin
+        scopes.push(scope)
+        yield
+      ensure
+        scopes.pop
+      end
     end
 
     def within_fieldset(locator)
-      within XPath.fieldset(locator) do
+      within :xpath, XPath.fieldset(locator) do
         yield
       end
     end
 
     def within_table(locator)
-      within XPath.table(locator) do
+      within :xpath, XPath.table(locator) do
         yield
       end
     end
 
     def has_xpath?(path, options={})
       wait_conditionally_until do
-        results = all(path, options)
+        results = all(:xpath, path, options)
 
         if options[:count]
           results.size == options[:count]
@@ -134,7 +155,7 @@ module Capybara
 
     def has_no_xpath?(path, options={})
       wait_conditionally_until do
-        results = all(path, options)
+        results = all(:xpath, path, options)
 
         if options[:count]
           results.size != options[:count]
@@ -162,16 +183,64 @@ module Capybara
       has_no_xpath?(XPath.content(content))
     end
 
+    def has_link?(locator)
+      has_xpath?(XPath.link(locator))
+    end
+
+    def has_no_link?(locator)
+      has_no_xpath?(XPath.link(locator))
+    end
+
+    def has_button?(locator)
+      has_xpath?(XPath.button(locator))
+    end
+
+    def has_no_button?(locator)
+      has_no_xpath?(XPath.button(locator))
+    end
+
+    def has_field?(locator, options={})
+      has_xpath?(XPath.field(locator, options))
+    end
+
+    def has_no_field?(locator, options={})
+      has_no_xpath?(XPath.field(locator, options))
+    end
+
+    def has_checked_field?(locator)
+      has_xpath?(XPath.field(locator, :checked => true))
+    end
+
+    def has_unchecked_field?(locator)
+      has_xpath?(XPath.field(locator, :unchecked => true))
+    end
+
+    def has_select?(locator, options={})
+      has_xpath?(XPath.select(locator, options))
+    end
+
+    def has_no_select?(locator, options={})
+      has_no_xpath?(XPath.select(locator, options))
+    end
+
+    def has_table?(locator, options={})
+      has_xpath?(XPath.table(locator, options))
+    end
+
+    def has_no_table?(locator, options={})
+      has_no_xpath?(XPath.table(locator, options))
+    end
+
     def save_and_open_page
       require 'capybara/save_and_open_page'
       Capybara::SaveAndOpenPage.save_and_open_page(body)
     end
 
     #return node identified by locator or raise ElementNotFound(using desc)
-    def locate(locator, fail_msg = nil)
-      node = wait_conditionally_until { find(locator) }
+    def locate(kind_or_locator, locator=nil, fail_msg = nil)
+      node = wait_conditionally_until { find(kind_or_locator, locator) }
     ensure
-      raise Capybara::ElementNotFound, fail_msg || "Unable to locate '#{locator}'" unless node
+      raise Capybara::ElementNotFound, fail_msg || "Unable to locate '#{kind_or_locator}'" unless node
       return node
     end
 

data/lib/capybara/xpath.rb

@@ -33,13 +33,21 @@ module Capybara
       @paths = paths
     end
 
-    def field(locator)
-      fillable_field(locator).input_field(:file, locator).checkbox(locator).radio_button(locator).select(locator)
+    def field(locator, options={})
+      if options[:with]
+        fillable_field(locator, options)
+      else
+        xpath = fillable_field(locator)
+        xpath = xpath.input_field(:file, locator, options)
+        xpath = xpath.checkbox(locator, options)
+        xpath = xpath.radio_button(locator, options)
+        xpath.select(locator, options)
+      end
     end
 
-    def fillable_field(locator)
-      [:text, :password, :email, :url, :search, :tel, :color].inject(text_area(locator)) do |all, type|
-        all.input_field(type, locator)
+    def fillable_field(locator, options={})
+      [:text, :password, :email, :url, :search, :tel, :color].inject(text_area(locator, options)) do |all, type|
+        all.input_field(type, locator, options)
       end
     end
 
@@ -47,8 +55,16 @@ module Capybara
       append("/descendant-or-self::*[contains(.,#{s(locator)})]")
     end
 
-    def table(locator)
-      append("//table[@id=#{s(locator)} or contains(caption,#{s(locator)})]")
+    def table(locator, options={})
+      conditions = ""
+      if options[:rows]
+        row_conditions = options[:rows].map do |row|
+          row = row.map { |column| "*[self::td or self::th][text()=#{s(column)}]" }.join(sibling)
+          "tr[./#{row}]"
+        end.join(sibling)
+        conditions << "[.//#{row_conditions}]"
+      end
+      append("//table[@id=#{s(locator)} or contains(caption,#{s(locator)})]#{conditions}")
     end
 
     def fieldset(locator)
@@ -56,27 +72,30 @@ module Capybara
     end
 
     def link(locator)
-      xpath = append("//a[@href][@id=#{s(locator)} or contains(.,#{s(locator)}) or contains(@title,#{s(locator)})]")
-      xpath.prepend("//a[@href][text()=#{s(locator)} or @title=#{s(locator)}]")
+      xpath = append("//a[@href][@id=#{s(locator)} or contains(.,#{s(locator)}) or contains(@title,#{s(locator)}) or img[contains(@alt,#{s(locator)})]]")
+      xpath.prepend("//a[@href][text()=#{s(locator)} or @title=#{s(locator)} or img[@alt=#{s(locator)}]]")
     end
 
     def button(locator)
-      xpath = append("//input[@type='submit' or @type='image'][@id=#{s(locator)} or contains(@value,#{s(locator)})]")
+      xpath = append("//input[@type='submit' or @type='image' or @type='button'][@id=#{s(locator)} or contains(@value,#{s(locator)})]")
       xpath = xpath.append("//button[@id=#{s(locator)} or contains(@value,#{s(locator)}) or contains(.,#{s(locator)})]")
-      xpath = xpath.prepend("//input[@type='submit' or @type='image'][@value=#{s(locator)}]")
+      xpath = xpath.prepend("//input[@type='submit' or @type='image' or @type='button'][@value=#{s(locator)}]")
+      xpath = xpath.prepend("//input[@type='image'][@alt=#{s(locator)} or contains(@alt,#{s(locator)})]")
       xpath = xpath.prepend("//button[@value=#{s(locator)} or text()=#{s(locator)}]")
     end
 
-    def text_area(locator)
-      add_field(locator, "//textarea")
+    def text_area(locator, options={})
+      options = options.merge(:text => options[:with]) if options.has_key?(:with)
+      add_field(locator, "//textarea", options)
     end
 
-    def select(locator)
-      add_field(locator, "//select")
+    def select(locator, options={})
+      add_field(locator, "//select", options)
     end
 
-    def input_field(type, locator)
-      add_field(locator, "//input[@type='#{type}']")
+    def input_field(type, locator, options={})
+      options = options.merge(:value => options[:with]) if options.has_key?(:with)
+      add_field(locator, "//input[@type='#{type}']", options)
     end
 
     def scope(scope)
@@ -95,12 +114,12 @@ module Capybara
       XPath.new(*[XPath.wrap(path).paths, @paths].flatten)
     end
 
-    def checkbox(locator)
-      input_field(:checkbox, locator)
+    def checkbox(locator, options={})
+      input_field(:checkbox, locator, options)
     end
 
-    def radio_button(locator)
-      input_field(:radio, locator)
+    def radio_button(locator, options={})
+      input_field(:radio, locator, options)
     end
 
     [:text, :password, :email, :url, :search, :tel, :color, :file].each do |type|
@@ -113,12 +132,32 @@ module Capybara
 
   protected
 
-    def add_field(locator, field)
-      xpath = append("#{field}[@id=#{s(locator)}]")
-      xpath = xpath.append("#{field}[@name=#{s(locator)}]")
-      xpath = xpath.append("#{field}[@id=//label[contains(.,#{s(locator)})]/@for]")
-      xpath = xpath.append("//label[contains(.,#{s(locator)})]#{field}")
-      xpath.prepend("#{field}[@id=//label[text()=#{s(locator)}]/@for]")
+    # place this between to nodes to indicate that they should be siblings
+    def sibling
+      '/following-sibling::*[1]/self::'
+    end
+
+    def add_field(locator, field, options={})
+      postfix = extract_postfix(options)
+      xpath = append("#{field}[@id=#{s(locator)}]#{postfix}")
+      xpath = xpath.append("#{field}[@name=#{s(locator)}]#{postfix}")
+      xpath = xpath.append("#{field}[@id=//label[contains(.,#{s(locator)})]/@for]#{postfix}")
+      xpath = xpath.append("//label[contains(.,#{s(locator)})]#{field}#{postfix}")
+      xpath.prepend("#{field}[@id=//label[text()=#{s(locator)}]/@for]#{postfix}")
+    end
+
+    def extract_postfix(options)
+      options.inject("") do |postfix, (key, value)|
+        case key
+          when :value     then postfix += "[@value=#{s(value)}]"
+          when :text      then postfix += "[text()=#{s(value)}]"
+          when :checked   then postfix += "[@checked]"
+          when :unchecked then postfix += "[not(@checked)]"
+          when :options   then postfix += value.map { |o| "[./option/text()=#{s(o)}]" }.join
+          when :selected  then postfix += [value].flatten.map { |o| "[./option[@selected]/text()=#{s(o)}]" }.join
+        end
+        postfix
+      end
     end
 
     # Sanitize a String for putting it into an xpath query