yannp-capybara 0.3.9

data/lib/capybara/rails.rb

@@ -0,0 +1,17 @@
+require 'capybara'
+require 'capybara/dsl'
+
+Capybara.app = Rack::Builder.new do
+  map "/" do
+    if Rails.version.to_f >= 3.0
+      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')
+Capybara.save_and_open_page_path = Rails.root.join('tmp/capybara')
+

data/lib/capybara/server.rb

@@ -0,0 +1,101 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+require 'capybara/util/timeout'
+
+module Capybara
+  class Server
+    class Identify
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env["PATH_INFO"] == "/__identify__"
+          [200, {}, @app.object_id.to_s]
+        else
+          @app.call(env)
+        end
+      end
+    end
+
+    class << self
+      def ports
+        @ports ||= {}
+      end
+    end
+
+    attr_reader :app, :port
+
+    def initialize(app)
+      @app = app
+    end
+
+    def host
+      "localhost" 
+    end
+
+    def url(path)
+      if path =~ /^http/
+        path
+      else
+        (Capybara.app_host || "http://#{host}:#{port}") + path.to_s
+      end
+    end
+
+    def responsive?
+      res = Net::HTTP.start(host, @port) { |http| http.get('/__identify__') }
+
+      if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
+        return res.body == @app.object_id.to_s
+      end
+    rescue Errno::ECONNREFUSED, Errno::EBADF
+      return false
+    end
+
+    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
+      if @app
+        @port = Capybara::Server.ports[@app.object_id]
+          
+        if not @port or not responsive?
+          @port = find_available_port
+          Capybara::Server.ports[@app.object_id] = @port
+
+          Thread.new { handler.run(Identify.new(@app), :Port => @port, :AccessLog => []) }
+
+          Capybara.timeout(10) { if responsive? then true else sleep(0.5) and false end }
+        end
+      end
+    rescue Timeout::Error
+      puts "Rack application timed out during boot"
+      exit
+    else
+      self
+    end
+
+  private
+
+    def find_available_port
+      server = TCPServer.new('127.0.0.1', 0)
+      server.addr[1]
+    ensure
+      server.close if server
+    end
+
+  end
+end

data/lib/capybara/session.rb

@@ -0,0 +1,278 @@
+require 'capybara/util/timeout'
+
+module Capybara
+
+  ##
+  #
+  # The Session class represents a single user's interaction with the system. The Session can use
+  # any of the underlying drivers. A session can be initialized manually like this:
+  #
+  #     session = Capybara::Session.new(:culerity, MyRackApp)
+  #
+  # The application given as the second argument is optional. When running Capybara against an external
+  # page, you might want to leave it out:
+  #
+  #     session = Capybara::Session.new(:culerity)
+  #     session.visit('http://www.google.com')
+  #
+  # Session provides a number of methods for controlling the navigation of the page, such as +visit+,
+  # +current_path, and so on. It also delegate a number of methods to a Capybara::Document, representing
+  # the current HTML document. This allows interaction:
+  #
+  #     session.fill_in('q', :with => 'Capybara')
+  #     session.click_button('Search')
+  #     session.should have_content('Capybara')
+  #
+  # When using capybara/dsl, the Session is initialized automatically for you.
+  #
+  class Session
+    DSL_METHODS = [
+      :all, :attach_file, :body, :check, :choose, :click_link_or_button, :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, :within_frame, :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?, :current_path, :scope_to, :click, :driver
+    ]
+
+    attr_reader :mode, :app
+
+    def initialize(mode, app=nil)
+      @mode = mode
+      @app = app
+    end
+
+    def driver
+      @driver ||= begin                    
+        string = mode.to_s
+        string.gsub!(%r{(^.)|(_.)}) { |m| m[m.length-1,1].upcase }
+        Capybara::Driver.const_get(string.to_sym).new(app)
+      rescue NameError
+        raise Capybara::DriverNotFoundError, "no driver called #{mode} was found"
+      end
+    end
+
+    ##
+    #
+    # Reset the session, removing all cookies.
+    #
+    def cleanup!
+      driver.cleanup!
+    end
+
+    ##
+    #
+    # Returns a hash of response headers. Not supported by all drivers (e.g. Selenium)
+    #
+    # @return [Hash{String => String}] A hash of response headers.
+    #
+    def response_headers
+      driver.response_headers
+    end
+
+    ##
+    #
+    # Returns the current HTTP status code as an Integer. Not supported by all drivers (e.g. Selenium)
+    #
+    # @return [Integer] Current HTTP status code
+    #
+    def status_code
+      driver.status_code
+    end
+
+    ##
+    #
+    # @return [String] A snapshot of the HTML of the current document, as it looks right now
+    #
+    def body
+      driver.body
+    end
+
+    ##
+    #
+    # @return [String] HTML source of the document, before being modified by JavaScript.
+    #
+    def source
+      driver.source
+    end
+
+    ##
+    #
+    # @return [String] Path of the current page, without any domain information
+    #
+    def current_path
+      URI.parse(current_url).path
+    end
+
+    ##
+    #
+    # @return [String] Fully qualified URL of the current page
+    #
+    def current_url
+      driver.current_url
+    end
+
+    ##
+    #
+    # Navigate to the given URL. The URL can either be a relative URL or an absolute URL
+    # The behaviour of either depends on the driver.
+    #
+    #     session.visit('/foo')
+    #     session.visit('http://google.com')
+    #
+    # For drivers which can run against an external application, such as culerity and selenium
+    # giving an absolute URL will navigate to that page. This allows testing applications
+    # running on remote servers. For these drivers, setting Capybara.app_host will make the
+    # remote server the default. For example:
+    #
+    #     Capybara.app_host = 'http://google.com'
+    #     session.visit('/') # visits the google homepage
+    #
+    # @param [String] url     The URL to navigate to
+    #
+    def visit(url)
+      driver.visit(url)
+    end
+
+    ##
+    #
+    # Execute the given block for a particular scope on the page. Within will find the first
+    # element matching the given selector and execute the block scoped to that element:
+    #
+    #     within(:xpath, '//div[@id="delivery-address"]') do
+    #       fill_in('Street', :with => '12 Main Street')
+    #     end
+    #
+    # It is possible to omit the first parameter, in that case, the selector is assumed to be
+    # of the type set in Capybara.default_selector.
+    #
+    #     within('div#delivery-address') do
+    #       fill_in('Street', :with => '12 Main Street')
+    #     end
+    #
+    # @param [:css, :xpath, String] kind    The type of selector or the selector if the second argument is blank
+    # @param [String] selector              The selector within which to execute the given block
+    #
+    def within(kind, selector=nil)
+      new_scope = find(kind, selector, :message => "scope '#{selector || kind}' not found on page")
+      begin
+        scopes.push(new_scope)
+        yield
+      ensure
+        scopes.pop
+      end
+    end
+
+    ##
+    #
+    # Execute the given block within the a specific fieldset given the id or legend of that fieldset.
+    #
+    # @param [String] locator    Id or legend of the fieldset
+    #
+    def within_fieldset(locator)
+      within :xpath, XPath.fieldset(locator) do
+        yield
+      end
+    end
+
+    ##
+    #
+    # Execute the given block within the a specific table given the id or caption of that table.
+    #
+    # @param [String] locator    Id or caption of the table
+    #
+    def within_table(locator)
+      within :xpath, XPath.table(locator) do
+        yield
+      end
+    end
+
+    ##
+    #
+    # Execute the given block within the given iframe given the id of that iframe. Only works on
+    # some drivers (e.g. Selenium)
+    #
+    # @param [String] locator    Id of the frame
+    #
+    def within_frame(frame_id)
+      driver.within_frame(frame_id) do
+        yield
+      end
+    end
+
+    ##
+    #
+    # Retry executing the block until a truthy result is returned or the timeout time is exceeded
+    #
+    # @param [Integer] timeout   The amount of seconds to retry executing the given block
+    #
+    def wait_until(timeout = Capybara.default_wait_time)
+      Capybara.timeout(timeout,driver) { yield }
+    end
+
+    ##
+    #
+    # Execute the given script, not returning a result. This is useful for scripts that return
+    # complex objects, such as jQuery statements. +execute_script+ should always be used over
+    # +evaluate_script+ whenever possible.
+    #
+    # @param [String] script   A string of JavaScript to execute
+    #
+    def execute_script(script)
+      driver.execute_script(script)
+    end
+
+    ##
+    #
+    # Evaluate the given JavaScript and return the result. Be careful when using this with
+    # scripts that return complex objects, such as jQuery statements. +execute_script+ might
+    # be a better alternative.
+    #
+    # @param  [String] script   A string of JavaScript to evaluate
+    # @return [Object]          The result of the evaluated JavaScript (may be driver specific)
+    #
+    def evaluate_script(script)
+      driver.evaluate_script(script)
+    end
+
+    ##
+    #
+    # @deprecated click is deprecated, please use {Capybara::Node::Actions#click_link_or_button} instead
+    #
+    def click(locator)
+      warn "DEPRECATED: click is deprecated, use click_link_or_button instead"
+      current_node.click_link_or_button(locator)
+    end
+
+    ##
+    #
+    # Save a snapshot of the page and open it in a browser for inspection
+    #
+    def save_and_open_page
+      require 'capybara/util/save_and_open_page'
+      Capybara.save_and_open_page(body)
+    end
+
+    def document
+      Capybara::Document.new(self, driver)
+    end
+
+    def method_missing(*args)
+      current_node.send(*args)
+    end
+
+    def respond_to?(method)
+      super || current_node.respond_to?(method)
+    end
+
+  private
+
+    def current_node
+      scopes.last
+    end
+
+    def scopes
+      @scopes ||= [document]
+    end
+  end
+end

data/lib/capybara/spec/driver.rb

@@ -0,0 +1,190 @@
+require 'capybara/spec/test_app'
+
+shared_examples_for 'driver' do
+
+  describe '#visit' do
+    it "should move to another page" do
+      @driver.visit('/')
+      @driver.body.should include('Hello world!')
+      @driver.visit('/foo')
+      @driver.body.should include('Another World')
+    end
+
+    it "should show the correct URL" do
+      @driver.visit('/foo')
+      @driver.current_url.should include('/foo')
+    end
+  end
+
+  describe '#body' do
+    it "should return text reponses" do
+      @driver.visit('/')
+      @driver.body.should include('Hello world!')
+    end
+
+    it "should return the full response html" do
+      @driver.visit('/with_simple_html')
+      @driver.body.should include('Bar')
+    end
+  end
+
+  describe '#find' do
+    context "with xpath selector" do
+      before do
+        @driver.visit('/with_html')
+      end
+
+      it "should extract node texts" 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'
+        @driver.find('//a')[1][:href].should == '/foo'
+        @driver.find('//a')[1][:id].should == 'foo'
+        @driver.find('//a')[1][:rel].should be_nil
+      end
+
+      it "should extract boolean node attributes" do
+        @driver.find('//input[@id="checked_field"]')[0][:checked].should be_true
+      end
+
+      it "should allow retrieval of the value" do
+        @driver.find('//textarea').first.value.should == 'banana'
+      end
+
+      it "should allow assignment of field value" do
+        @driver.find('//input').first.value.should == 'monkey'
+        @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'
+        @driver.find('//p')[1].tag_name.should == 'p'
+      end
+
+      it "should extract node visibility" do
+        @driver.find('//a')[0].should be_visible
+
+        @driver.find('//div[@id="hidden"]')[0].should_not be_visible
+        @driver.find('//div[@id="hidden_via_ancestor"]')[0].should_not be_visible
+      end
+    end
+  end
+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.find('//p').first.text.should == 'I changed it'
+    end
+  end
+
+  describe '#drag_to' do
+    it "should drag and drop an object" do
+      pending "drag/drop is currently broken under celerity/culerity" if @driver.is_a?(Capybara::Driver::Celerity)
+      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_empty
+    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
+
+shared_examples_for "driver with header support" do
+  it "should make headers available through response_headers" do
+    @driver.visit('/with_simple_html')
+    @driver.response_headers['Content-Type'].should == 'text/html'
+  end
+end
+
+shared_examples_for "driver with status code support" do
+  it "should make the status code available through status_code" do
+    @driver.visit('/with_simple_html')
+    @driver.status_code.should == 200
+  end
+end
+
+shared_examples_for "driver without status code support" do
+  it "should raise when trying to access the status code available through status_code" do
+    @driver.visit('/with_simple_html')
+    lambda {
+      @driver.status_code
+    }.should raise_error(Capybara::NotSupportedByDriverError)
+  end
+end
+
+shared_examples_for "driver with frame support" do
+  describe '#within_frame' do
+    before(:each) do
+      @driver.visit('/within_frames')
+    end
+
+    it "should find the div in frameOne" do
+      @driver.within_frame("frameOne") do
+        @driver.find("//*[@id='divInFrameOne']")[0].text.should eql 'This is the text of divInFrameOne'
+      end
+    end
+    it "should find the div in FrameTwo" do
+      @driver.within_frame("frameTwo") do
+        @driver.find("//*[@id='divInFrameTwo']")[0].text.should eql 'This is the text of divInFrameTwo'
+      end
+    end
+    it "should find the text div in the main window after finding text in frameOne" do
+      @driver.within_frame("frameOne") do
+        @driver.find("//*[@id='divInFrameOne']")[0].text.should eql 'This is the text of divInFrameOne'
+      end
+      @driver.find("//*[@id='divInMainWindow']")[0].text.should eql 'This is the text for divInMainWindow'
+    end
+    it "should find the text div in the main window after finding text in frameTwo" do
+      @driver.within_frame("frameTwo") do
+        @driver.find("//*[@id='divInFrameTwo']")[0].text.should eql 'This is the text of divInFrameTwo'
+      end
+      @driver.find("//*[@id='divInMainWindow']")[0].text.should eql 'This is the text for divInMainWindow'
+    end
+  end
+end
+
+shared_examples_for "driver with cookies support" do
+  describe "#cleanup" do
+    it "should set and clean cookies" do
+      @driver.visit('/get_cookie')
+      @driver.body.should_not include('test_cookie')
+
+      @driver.visit('/set_cookie')
+      @driver.body.should include('Cookie set to test_cookie')
+
+      @driver.visit('/get_cookie')
+      @driver.body.should include('test_cookie')
+
+      @driver.cleanup!
+      @driver.visit('/get_cookie')
+      @driver.body.should_not include('test_cookie')
+    end
+  end
+end
+
+shared_examples_for "driver with infinite redirect detection" do
+  it "should follow 5 redirects" do
+    @driver.visit('/redirect/5/times')
+    @driver.body.should include('redirection complete')
+  end
+
+  it "should not follow more than 5 redirects" do
+    running do
+      @driver.visit('/redirect/6/times')
+    end.should raise_error(Capybara::InfiniteRedirectError)
+  end
+end

data/lib/capybara/spec/fixtures/test_file.txt

@@ -0,0 +1 @@
+ThisIsTheTestFile