capybara 0.1.3 → 0.1.4

data/lib/capybara/rails.rb

@@ -1,10 +1,6 @@
 require 'capybara'
 require 'capybara/dsl'
 
-require 'database_cleaner'
-require 'database_cleaner/cucumber'
-DatabaseCleaner.strategy = :truncation
-
 Capybara.app = Rack::Builder.new do
   map "/" do
     use Rails::Rack::Static

data/lib/capybara/server.rb

@@ -1,5 +1,7 @@
+require 'uri'
 require 'net/http'
 require 'rack'
+require 'rack/handler/mongrel'
 
 class Capybara::Server
   attr_reader :app
@@ -17,6 +19,7 @@ class Capybara::Server
   end
 
   def url(path)
+    path = URI.parse(path).request_uri if path =~ /^http/
     "http://#{host}:#{port}#{path}"
   end
   

data/lib/capybara/session.rb

@@ -1,26 +1,6 @@
 module Capybara
-
-  class << self
-    attr_writer :default_selector
-
-    def default_selector
-      @default_selector ||= :xpath
-    end
-  end
-
   class Session
 
-    FIELDS_PATHS = {
-      :text_field => proc { |id| "//input[@type='text'][@id='#{id}']" },
-      :text_area => proc { |id| "//textarea[@id='#{id}']" },
-      :password_field => proc { |id| "//input[@type='password'][@id='#{id}']" },
-      :radio => proc { |id| "//input[@type='radio'][@id='#{id}']" },
-      :hidden_field => proc { |id| "//input[@type='hidden'][@id='#{id}']" },
-      :checkbox => proc { |id| "//input[@type='checkbox'][@id='#{id}']" },
-      :select => proc { |id| "//select[@id='#{id}']" },
-      :file_field => proc { |id| "//input[@type='file'][@id='#{id}']" }
-    }
-
     attr_reader :mode, :app
 
     def initialize(mode, app)
@@ -46,35 +26,59 @@ module Capybara
     end
 
     def click_link(locator)
-      find_link(locator).click
+      link = wait_for(XPath.link(locator))
+      raise Capybara::ElementNotFound, "no link with title, id or text '#{locator}' found" unless link
+      link.click
     end
 
     def click_button(locator)
-      find_button(locator).click
+      button = wait_for(XPath.button(locator))
+      raise Capybara::ElementNotFound, "no button with value or id or text '#{locator}' found" unless button
+      button.click
+    end
+
+    def drag(source_locator, target_locator)
+      source = find(source_locator)
+      raise Capybara::ElementNotFound, "drag source '#{source_locator}' not found on page" unless source
+      target = find(target_locator)
+      raise Capybara::ElementNotFound, "drag target '#{target_locator}' not found on page" unless target
+      source.drag_to(target)
     end
 
     def fill_in(locator, options={})
-      find_field(locator, :text_field, :text_area, :password_field).set(options[:with])
+      field = wait_for(XPath.fillable_field(locator))
+      raise Capybara::ElementNotFound, "cannot fill in, no text field, text area or password field with id or label '#{locator}' found" unless field
+      field.set(options[:with])
     end
 
     def choose(locator)
-      find_field(locator, :radio).set(true)
+      field = wait_for(XPath.radio_button(locator))
+      raise Capybara::ElementNotFound, "cannot choose field, no radio button with id or label '#{locator}' found" unless field
+      field.set(true)
     end
 
     def check(locator)
-      find_field(locator, :checkbox).set(true)
+      field = wait_for(XPath.checkbox(locator))
+      raise Capybara::ElementNotFound, "cannot check field, no checkbox with id or label '#{locator}' found" unless field
+      field.set(true)
     end
 
     def uncheck(locator)
-      find_field(locator, :checkbox).set(false)
+      field = wait_for(XPath.checkbox(locator))
+      raise Capybara::ElementNotFound, "cannot uncheck field, no checkbox with id or label '#{locator}' found" unless field
+      field.set(false)
     end
 
     def select(value, options={})
-      find_field(options[:from], :select).select(value)
+      field = wait_for(XPath.select(options[:from]))
+      raise Capybara::ElementNotFound, "cannot select option, no select box with id or label '#{options[:from]}' found" unless field
+      field.select(value)
     end
 
     def attach_file(locator, path)
-      find_field(locator, :file_field).set(path)
+      field = wait_for(XPath.file_field(locator))
+      raise Capybara::ElementNotFound, "cannot attach file, no file field with id or label '#{locator}' found" unless field
+      field.set(path)
     end
 
     def body
@@ -82,11 +86,11 @@ module Capybara
     end
 
     def has_content?(content)
-      has_xpath?("//*[contains(.,#{sanitized_xpath_string(content)})]")
+      has_xpath?(XPath.content(content).to_s)
     end
 
     def has_xpath?(path, options={})
-      results = find(path)
+      results = all(path)
       if options[:text]
         results = filter_by_text(results, options[:text])
       end
@@ -104,20 +108,20 @@ module Capybara
     def within(kind, scope=nil)
       kind, scope = Capybara.default_selector, kind unless scope
       scope = css_to_xpath(scope) if kind == :css
-      raise Capybara::ElementNotFound, "scope '#{scope}' not found on page" if find(scope).empty?
+      raise Capybara::ElementNotFound, "scope '#{scope}' not found on page" unless wait_for(scope)
       scopes.push(scope)
       yield
       scopes.pop
     end
 
     def within_fieldset(locator)
-      within "//fieldset[@id='#{locator}' or contains(legend,'#{locator}')]" do
+      within XPath.fieldset(locator) do
         yield
       end
     end
 
     def within_table(locator)
-      within "//table[@id='#{locator}' or contains(caption,'#{locator}')]" do
+      within XPath.table(locator) do
         yield
       end
     end
@@ -127,25 +131,45 @@ module Capybara
       Capybara::SaveAndOpenPage.save_and_open_page(body)
     end
 
-    def find_field(locator, *kinds)
-      kinds = FIELDS_PATHS.keys if kinds.empty?
-      field = find_field_by_id(locator, *kinds) || find_field_by_label(locator, *kinds)
-      raise Capybara::ElementNotFound, "no field of kind #{kinds.inspect} with id or label '#{locator}' found" unless field
-      field
+    def all(locator)
+      XPath.wrap(locator).scope(current_scope).paths.map do |path|
+        driver.find(path)
+      end.flatten
+    end
+
+    def find(locator)
+      all(locator).first
+    end
+    
+    def wait_for(locator)
+      return find(locator) unless driver.wait?
+      8.times do
+        result = find(locator)
+        return result if result
+        sleep(0.1)
+      end
+      nil
+    end
+
+    def find_field(locator)
+      find(XPath.field(locator))
     end
     alias_method :field_labeled, :find_field
 
     def find_link(locator)
-      link = find("//a[@id='#{locator}' or contains(.,'#{locator}') or @title='#{locator}']").first
-      raise Capybara::ElementNotFound, "no link with title, id or text '#{locator}' found" unless link
-      link
+      find(XPath.link(locator))
     end
 
     def find_button(locator)
-      button = find("//input[@type='submit' or @type='image'][@id='#{locator}' or @value='#{locator}']").first \
-               || find("//button[@id='#{locator}' or @value='#{locator}' or contains(.,'#{locator}')]").first
-      raise Capybara::ElementNotFound, "no button with value or id or text '#{locator}' found" unless button
-      button
+      find(XPath.button(locator))
+    end
+
+    def evaluate_script(script)
+      begin
+        driver.evaluate_script(script)
+      rescue NoMethodError
+        raise NotSupportedByDriverError
+      end
     end
 
   private
@@ -172,41 +196,5 @@ module Capybara
     def scopes
       @scopes ||= []
     end
-
-    def find_field_by_id(locator, *kinds)
-      kinds.each do |kind|
-        path = FIELDS_PATHS[kind]
-        element = find(path.call(locator)).first
-        return element if element
-      end
-      return nil
-    end
-
-    def find_field_by_label(locator, *kinds)
-      kinds.each do |kind|
-        label = find("//label[contains(.,'#{locator}')]").first
-        if label
-          element = find_field_by_id(label[:for], kind)
-          return element if element
-        end
-      end
-      return nil
-    end
-
-    def find(locator)
-      locator = current_scope.to_s + locator
-      driver.find(locator)
-    end
-
-    def sanitized_xpath_string(string)
-      if string =~ /'/
-        string = string.split("'", -1).map do |substr|
-          "'#{substr}'"
-        end.join(%q{,"'",})
-        "concat(#{string})"
-      else
-        "'#{string}'"
-      end
-    end
   end
 end

data/lib/capybara/xpath.rb

@@ -0,0 +1,124 @@
+module Capybara
+  # this is a class for generating XPath queries, use it like this:
+  #     Xpath.text_field('foo').link('blah').to_s
+  # this will generate an XPath that matches either a text field or a link
+  class XPath
+    class << self
+      def wrap(path)
+        if path.is_a?(self)
+          path
+        else
+          new(path.to_s)
+        end
+      end
+      
+      def respond_to?(method)
+        new.respond_to?(method)
+      end
+
+      def method_missing(*args)
+        new.send(*args)
+      end
+    end
+
+    attr_reader :paths
+
+    def initialize(*paths)
+      @paths = paths
+    end
+    
+    def field(locator)
+      fillable_field(locator).file_field(locator).checkbox(locator).radio_button(locator).select(locator)
+    end
+
+    def fillable_field(locator)
+      text_field(locator).password_field(locator).text_area(locator)
+    end
+    
+    def content(locator)
+      append("/descendant-or-self::*[contains(.,#{s(locator)})]")
+    end
+    
+    def table(locator)
+      append("//table[@id=#{s(locator)} or contains(caption,#{s(locator)})]")
+    end
+    
+    def fieldset(locator)
+      append("//fieldset[@id=#{s(locator)} or contains(legend,#{s(locator)})]")
+    end
+    
+    def link(locator)
+      append("//a[@id=#{s(locator)} or contains(.,#{s(locator)}) or @title=#{s(locator)}]")
+    end
+    
+    def button(locator)
+      xpath = append("//input[@type='submit' or @type='image'][@id=#{s(locator)} or @value=#{s(locator)}]")
+      xpath.append("//button[@id=#{s(locator)} or @value=#{s(locator)} or contains(.,#{s(locator)})]")
+    end
+
+    def text_field(locator)
+      add_field(locator) { |id| "//input[@type='text'][@id=#{id}]" }
+    end
+
+    def password_field(locator)
+      add_field(locator) { |id| "//input[@type='password'][@id=#{id}]" }
+    end
+
+    def text_area(locator)
+      add_field(locator) { |id| "//textarea[@id=#{id}]" }
+    end
+
+    def radio_button(locator)
+      add_field(locator) { |id| "//input[@type='radio'][@id=#{id}]" }
+    end
+
+    def checkbox(locator)
+      add_field(locator) { |id| "//input[@type='checkbox'][@id=#{id}]" }
+    end
+
+    def select(locator)
+      add_field(locator) { |id| "//select[@id=#{id}]" }
+    end
+
+    def file_field(locator)
+      add_field(locator) { |id| "//input[@type='file'][@id=#{id}]" }
+    end
+    
+    def scope(scope)
+      XPath.new(*paths.map { |p| scope + p })
+    end
+
+    def to_s
+      @paths.join(' | ')
+    end
+
+  protected
+  
+    def add_field(locator)
+      xpath = append(yield(s(locator)))
+      xpath = xpath.append(yield("//label[contains(.,#{s(locator)})]/@for"))
+      xpath.prepend(yield("//label[text()=#{s(locator)}]/@for"))
+    end
+  
+    # Sanitize a String for putting it into an xpath query
+    def s(string)
+      if string.include?("'")
+        string = string.split("'", -1).map do |substr|
+          "'#{substr}'"
+        end.join(%q{,"'",})
+        "concat(#{string})"
+      else
+        "'#{string}'"
+      end
+    end
+    
+    def prepend(path)
+      XPath.new(*[path, @paths].flatten)
+    end
+
+    def append(path)
+      XPath.new(*[@paths, path].flatten)
+    end
+
+  end
+end

data/spec/driver/selenium_driver_spec.rb

@@ -4,7 +4,7 @@ describe Capybara::Driver::Selenium do
   before do
     @driver = Capybara::Driver::Selenium.new(TestApp)
   end
-  
+
   it_should_behave_like "driver"
   it_should_behave_like "driver with javascript support"
 end

data/spec/drivers_spec.rb

@@ -37,7 +37,7 @@ shared_examples_for 'driver' do
         @driver.find('//a')[0].text.should == 'labore'
         @driver.find('//a')[1].text.should == 'ullamco'
       end
-      
+
       it "should extract node attributes" do
         @driver.find('//a')[0][:href].should == '/with_simple_html'
         @driver.find('//a')[0][:class].should == 'simple'
@@ -51,7 +51,7 @@ shared_examples_for 'driver' do
         @driver.find('//input').first.set('gorilla')
         @driver.find('//input').first.value.should == 'gorilla'
       end
-      
+
       it "should extract node tag name" do
         @driver.find('//a')[0].tag_name.should == 'a'
         @driver.find('//a')[1].tag_name.should == 'a'
@@ -63,10 +63,27 @@ shared_examples_for 'driver' do
 end
 
 shared_examples_for "driver with javascript support" do
+  before { @driver.visit('/with_js') }
+
   describe '#find' do
     it "should find dynamically changed nodes" do
-      @driver.visit('/with_js')
       @driver.find('//p').first.text.should == 'I changed it'
     end
   end
+
+  describe '#drag_to' do
+    it "should drag and drop an object" do
+      draggable = @driver.find('//div[@id="drag"]').first
+      droppable = @driver.find('//div[@id="drop"]').first
+      draggable.drag_to(droppable)
+      @driver.find('//div[contains(., "Dropped!")]').should_not be_nil
+    end
+  end
+
+  describe "#evaluate_script" do
+    it "should return the value of the executed script" do
+      @driver.evaluate_script('1+1').should == 2
+    end
+  end
+
 end

data/spec/dsl_spec.rb

@@ -36,7 +36,7 @@ describe Capybara do
       Capybara.current_driver.should == :culerity
     end
   end
-  
+
   describe '#javascript_driver' do
     it "should default to selenium" do
       Capybara.javascript_driver.should == :selenium
@@ -98,7 +98,7 @@ describe Capybara do
       Capybara.current_session.app.should == Capybara.app
     end
   end
-  
+
   describe '.reset_sessions!' do
     it "should clear any persisted sessions" do
       object_id = Capybara.current_session.object_id
@@ -114,6 +114,7 @@ describe Capybara do
     end
 
     it_should_behave_like "session"
+    it_should_behave_like "session without javascript support"
 
     it "should be possible to include it in another class" do
       klass = Class.new do
@@ -124,7 +125,7 @@ describe Capybara do
       foo.click_link('ullamco')
       foo.body.should include('Another World')
     end
-    
+
     it "should provide a 'page' shortcut for more expressive tests" do
       klass = Class.new do
         include Capybara