ryansch-capybara-mechanize 1.0.0

data/README.mdown

@@ -0,0 +1,68 @@
+Capybara-mechanize
+==================
+
+This gems makes it possible to use Capybara for (partially) remote testing. It inherits most functionality from the RackTest driver and only uses [Mechanize](http://github.com/tenderlove/mechanize) for remote requests. 
+
+It is currently in use to test the integration between a Rails application and Twitter authorization and sharing.
+
+This gem is a [Capybara](http://github.com/jnicklas/capybara) extension. I have been inspired by the Capybara driver and some earlier efforts for a Mechanize driver.
+
+Thanks to [Pinkelstar](http://www.pinkelstar.com) for giving me the time and the need to develop this gem.
+
+### Installation
+
+    gem install capybara-mechanize
+
+### Usage without Cucumber
+
+    require 'capybara/mechanize'
+
+### Usage with Cucumber and tags
+
+A @mechanize tag is added to your hooks when you add the following line to your env.rb
+
+    require 'capybara/mechanize/cucumber'
+
+The following scenario will then be using the Mechanize driver
+
+    @mechanize
+    Scenario: do something remote
+      When I click the remote link
+      
+### Remote testing
+
+When you want to use this driver to test a remote application. You have to set the app_host:
+
+    Capybara.app_host = "http://www.yourapp.com"
+    
+Note that I haven't tested this case for my self yet. The Capybara tests pass for this situation though so it should work! Please provide me with feedback if it doesn't.
+
+## Running tests
+
+Run bundler
+
+    bundle install
+
+Then you are ready to run the test like so
+
+    bundle exec rake spec
+
+Todo
+----
+* Make the last 12 failing remote session spec pass, see remote_mechanize_spec and uncomment one line there to see them fail
+* Test this driver with non-rack/non-ruby projects
+
+Note on Patches/Pull Requests
+-----------------------------
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Copyright
+---------
+Copyright (c) 2010-2012 Jeroen van Dijk. See LICENSE for details.

data/lib/capybara/mechanize.rb

@@ -0,0 +1,24 @@
+require 'capybara'
+
+module Capybara::Mechanize
+  class << self
+
+    # Host that should be considered local (includes default_host)
+    def local_hosts
+      @local_hosts ||= begin
+        default_host = URI.parse(Capybara.default_host || "").host || Capybara.default_host
+        [default_host].compact
+      end
+    end
+    
+    def local_hosts=(hosts)
+      @local_hosts = hosts
+    end
+  end
+end
+
+require 'capybara/mechanize/driver'
+
+Capybara.register_driver :mechanize do |app|
+  Capybara::Mechanize::Driver.new(app)
+end

data/lib/capybara/mechanize/browser.rb

@@ -0,0 +1,172 @@
+require 'capybara/rack_test/driver'
+require 'mechanize'
+require 'capybara/mechanize/node'
+require 'capybara/mechanize/form'
+
+class Capybara::Mechanize::Browser < Capybara::RackTest::Browser
+  extend Forwardable
+
+  def_delegator :agent, :scheme_handlers
+  def_delegator :agent, :scheme_handlers=
+
+  def initialize(driver)
+    @agent = ::Mechanize.new
+    @agent.redirect_ok = false
+    @agent.user_agent = default_user_agent
+    super
+  end
+
+  def reset_host!
+    @last_remote_uri = nil
+    @last_request_remote = nil
+    super
+  end
+
+  def current_url
+    last_request_remote? ? remote_response.current_url : super
+  end
+
+  def last_response
+    last_request_remote? ? remote_response : super
+  end
+
+  # For each of these http methods, we want to intercept the method call.
+  # Then we determine if the call is remote or local.
+  # Remote: Handle it with our process_remote_request method.
+  # Local: Register the local request and call super to let RackTest get it.
+  [:get, :post, :put, :delete].each do |method|
+    define_method(method) do |path, params = {}, env = {}, &block|
+      path = @last_path if path.nil? || path.empty?
+
+      if remote?(path)
+        process_remote_request(method, path, params, env, &block)
+      else
+        register_local_request
+        super(path, params, env, &block)
+      end
+
+      @last_path = path
+    end
+  end
+
+  def remote?(url)
+    if Capybara.app_host
+      true
+    else
+      host = URI.parse(url).host
+
+      if host.nil?
+        last_request_remote?
+      else
+        !Capybara::Mechanize.local_hosts.include?(host)
+      end
+    end
+  end
+
+  def find(selector)
+    dom.xpath(selector).map { |node| Capybara::Mechanize::Node.new(self, node) }
+  end
+
+  attr_reader :agent
+
+  private
+
+  def last_request_remote?
+    !!@last_request_remote
+  end
+
+  def register_local_request
+    @last_remote_uri = nil
+    @last_request_remote = false
+  end
+
+  def remote_request_path
+    @last_remote_uri.nil? ? nil : @last_remote_uri.path
+  end
+
+  def request_path
+    last_request_remote? ? remote_request_path : super
+  end
+
+  def process_remote_request(method, url, attributes, headers)
+    if remote?(url)
+      uri = URI.parse(url)
+      @last_remote_uri = uri
+      url = uri.to_s
+
+      reset_cache!
+      begin
+        if method == :post
+          if attributes.is_a? Mechanize::Form
+            submit_mechanize_form(url, attributes, headers)
+          else
+            @agent.send(method, url, attributes, headers)
+          end
+        elsif method == :get
+          if attributes.is_a? Mechanize::Form
+            submit_mechanize_form(url, attributes, headers)
+          else
+            referer = headers['HTTP_REFERER']
+            @agent.send(method, url, attributes, referer, headers)
+          end
+        else
+          @agent.send(method, url, attributes, headers)
+        end
+      rescue => e
+        raise "Received the following error for a #{method.to_s.upcase} request to #{url}: '#{e.message}'"
+      end
+      @last_request_remote = true
+    end
+  end
+
+  def submit_mechanize_form(url, form, headers)
+    form.action = url
+    @agent.submit(form, nil, headers)
+  end
+
+  def remote_response
+    ResponseProxy.new(@agent.current_page) if @agent.current_page
+  end
+
+  def default_user_agent
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.853.0 Safari/535.2"
+  end
+
+  class ResponseProxy
+    extend Forwardable
+
+    def_delegator :page, :body
+
+    attr_reader :page
+
+    def initialize(page)
+      @page = page
+    end
+
+    def current_url
+      page.uri.to_s
+    end
+
+    def headers
+      # Hax the content-type contains utf8, so Capybara specs are failing, need to ask mailinglist
+      headers = page.response
+      headers["content-type"].gsub!(';charset=utf-8', '') if headers["content-type"]
+      headers
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def status
+      page.code.to_i
+    end
+
+    def redirect?
+      status >= 300 && status < 400
+    end
+
+  end
+
+end
+

data/lib/capybara/mechanize/cucumber.rb

@@ -0,0 +1,5 @@
+require 'capybara/mechanize'
+
+Before('@mechanize') do
+  Capybara.current_driver = :mechanize
+end

data/lib/capybara/mechanize/driver.rb

@@ -0,0 +1,19 @@
+require 'capybara/mechanize/browser'
+
+class Capybara::Mechanize::Driver < Capybara::RackTest::Driver
+  
+  def initialize(app, options = {})
+    raise ArgumentError, "mechanize requires a rack application, but none was given" unless app
+
+    super
+  end
+
+  def remote?(url)
+    browser.remote?(url)
+  end
+  
+  def browser
+    @browser ||= Capybara::Mechanize::Browser.new(self)
+  end
+  
+end

data/lib/capybara/mechanize/form.rb

@@ -0,0 +1,65 @@
+class Capybara::Mechanize::Form < Capybara::RackTest::Form
+
+  def params(button)
+    if !use_mechanize?
+      return super
+    end
+
+    node = {}
+    # Create a fake form
+    class << node
+      def search(*args); []; end
+    end
+    node['method'] = method.to_s.upcase
+
+    if self.multipart?
+      node['enctype'] = 'multipart/form-data'
+    else
+      node['enctype'] = 'application/x-www-form-urlencoded'
+    end
+
+    @m_form = Mechanize::Form.new(node, nil, form_referer)
+
+    super
+
+    @m_form
+  end
+
+  private
+
+  def merge_param!(params, key, value)
+    if !use_mechanize?
+      return super
+    end
+
+    if value.is_a? NilUploadedFile
+      # Adding a nil value here will result in the form element existing with the empty string as its value.
+      # Instead don't add the form element at all.
+      return params
+    end
+
+    if value.is_a? Rack::Test::UploadedFile
+      @m_form.enctype = 'multipart/form-data'
+
+      ul = Mechanize::Form::FileUpload.new({'name' => key.to_s}, value.original_filename)
+      ul.mime_type = value.content_type
+      ul.file_data = (value.rewind; value.read)
+
+      @m_form.file_uploads << ul
+
+      return params
+    end
+
+    @m_form.fields << Mechanize::Form::Field.new({'name' => key.to_s}, value)
+
+    params
+  end
+
+  def use_mechanize?
+    driver.remote?(native['action'].to_s)
+  end
+
+  def form_referer
+    driver.last_response.page
+  end
+end

data/lib/capybara/mechanize/node.rb

@@ -0,0 +1,10 @@
+class Capybara::Mechanize::Node < Capybara::RackTest::Node
+  def click
+    if tag_name == 'a'
+      super
+    elsif (tag_name == 'input' and %w(submit image).include?(type)) or
+        ((tag_name == 'button') and type.nil? or type == "submit")
+      Capybara::Mechanize::Form.new(driver, form).submit(self)
+    end
+  end
+end

data/lib/capybara/mechanize/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module Mechanize
+    VERSION = '1.0.0'
+  end
+end

data/lib/capybara/spec/extended_test_app.rb

@@ -0,0 +1,65 @@
+require 'capybara/spec/test_app'
+
+class ExtendedTestApp < TestApp#< Sinatra::Base
+  set :environment, :production # so we don't get debug info that makes our test pass!
+  disable :protection
+
+  get %r{/redirect_to/(.*)} do
+    redirect params[:captures].first
+  end
+
+  get '/form_with_relative_action_to_host' do
+    %{<form action="/request_info/host" method="post">
+       <input type="submit" value="submit" />
+      </form>}
+  end
+
+  get '/request_info/form_with_no_action' do
+    %{<form method="post">
+       <input type="submit" value="submit" />
+      </form>}
+  end
+
+  get '/relative_link_to_host' do
+    %{<a href="/request_info/host">host</a>}
+  end
+
+  get '/request_info/user_agent' do
+    request.user_agent
+  end
+
+  get '/request_info/*' do
+    current_request_info
+  end
+
+  post '/request_info/*' do
+    current_request_info
+  end
+
+  get '/subsite/relative_link_to_host' do
+    %{<a href="/subsite/request_info2/host">host</a>}
+  end
+
+  get '/subsite/local_link_to_host' do
+    %{<a href="request_info2/host">host</a>}
+  end
+
+  get '/subsite/request_info2/*' do
+    "subsite: " + current_request_info
+  end
+
+  get '/redirect_with_http_param' do
+    redirect '/redirect_target?foo=http'
+  end
+
+  get '/redirect_target' do
+    %{correct redirect}
+  end
+
+  private
+
+    def current_request_info
+      "Current host is #{request.url}, method #{request.request_method.downcase}"
+    end
+end
+

data/spec/driver/mechanize_driver_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe Capybara::Mechanize::Driver, 'local' do
+  let(:driver) { Capybara::Mechanize::Driver.new(ExtendedTestApp) }
+
+  describe ':headers option' do
+    it 'should always set headers' do
+      driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      driver.visit('/get_header')
+      driver.html.should include('foobar')
+    end
+
+    it 'should keep headers on link clicks' do
+      driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      driver.visit('/header_links')
+      driver.find('.//a').first.click
+      driver.html.should include('foobar')
+    end
+
+    it 'should keep headers on form submit' do
+      driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      driver.visit('/header_links')
+      driver.find('.//input').first.click
+      driver.html.should include('foobar')
+    end
+
+    it 'should keep headers on redirects' do
+      driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      driver.visit('/get_header_via_redirect')
+      driver.html.should include('foobar')
+    end
+  end
+
+  describe ':follow_redirects option' do
+    it "defaults to following redirects" do
+      driver = Capybara::RackTest::Driver.new(TestApp)
+
+      driver.visit('/redirect')
+      driver.response.header['Location'].should be_nil
+      driver.browser.current_url.should match %r{/landed$}
+    end
+
+    it "is possible to not follow redirects" do
+      driver = Capybara::RackTest::Driver.new(TestApp, :follow_redirects => false)
+
+      driver.visit('/redirect')
+      driver.response.header['Location'].should match %r{/redirect_again$}
+      driver.browser.current_url.should match %r{/redirect$}
+    end
+  end
+
+  describe ':redirect_limit option' do
+    context "with default redirect limit" do
+      let(:driver) { Capybara::RackTest::Driver.new(TestApp) }
+
+      it "should follow 5 redirects" do
+        driver.visit("/redirect/5/times")
+        driver.html.should include('redirection complete')
+      end
+
+      it "should not follow more than 6 redirects" do
+        expect do
+          driver.visit("/redirect/6/times")
+        end.to raise_error(Capybara::InfiniteRedirectError)
+      end
+    end
+
+    context "with 21 redirect limit" do
+      let(:driver) { Capybara::RackTest::Driver.new(TestApp, :redirect_limit => 21) }
+
+      it "should follow 21 redirects" do
+        driver.visit("/redirect/21/times")
+        driver.html.should include('redirection complete')
+      end
+
+      it "should not follow more than 21 redirects" do
+        expect do
+          driver.visit("/redirect/22/times")
+        end.to raise_error(Capybara::InfiniteRedirectError)
+      end
+    end
+  end
+
+  it "should default to local mode for relative paths" do
+    driver.should_not be_remote('/')
+  end
+
+  it "should default to local mode for the default host" do
+    driver.should_not be_remote('http://www.example.com')
+  end
+
+  context "with an app_host" do
+
+    before do
+      Capybara.app_host = 'http://www.remote.com'
+    end
+
+    after do
+      Capybara.app_host = nil
+    end
+
+    it "should treat urls as remote" do
+      driver.should be_remote('http://www.remote.com')
+    end
+  end
+
+  context "with a default url, no app host" do
+    before do
+      Capybara.default_host = 'www.local.com'
+    end
+
+    it "should allow local hosts to be set" do
+      Capybara::Mechanize.local_hosts = ['subdomain.local.com']
+      driver.should_not be_remote('http://subdomain.local.com')
+    end
+
+    it "should treat urls with the same host names as local" do
+      driver.should_not be_remote('http://www.local.com')
+    end
+
+    it "should treat other urls as remote" do
+      driver.should be_remote('http://www.remote.com')
+    end
+
+    it "should treat relative paths as remote if the previous request was remote" do
+      driver.visit(REMOTE_TEST_URL)
+      driver.should be_remote('/some_relative_link')
+    end
+
+    it "should treat relative paths as local if the previous request was local" do
+      driver.visit('http://www.local.com')
+      driver.should_not be_remote('/some_relative_link')
+    end
+
+    it "should receive the right host" do
+      driver.visit('http://www.local.com/host')
+      should_be_a_local_get
+    end
+
+    it "should consider relative paths to be local when the previous request was local" do
+      driver.visit('http://www.local.com/host')
+      driver.visit('/host')
+
+      should_be_a_local_get
+      driver.should_not be_remote('/first_local')
+    end
+
+    it "should consider relative paths to be remote when the previous request was remote" do
+      driver.visit("#{REMOTE_TEST_URL}/host")
+      driver.get('/host')
+
+      should_be_a_remote_get
+      driver.should be_remote('/second_remote')
+    end
+
+    it "should always switch to the right context" do
+      driver.visit('http://www.local.com/host')
+      driver.get('/host')
+      driver.get("#{REMOTE_TEST_URL}/host")
+      driver.get('/host')
+      driver.get('http://www.local.com/host')
+
+      should_be_a_local_get
+      driver.should_not be_remote('/second_local')
+    end
+
+    it "should follow redirects from local to remote" do
+      driver.visit("http://www.local.com/redirect_to/#{REMOTE_TEST_URL}/host")
+      should_be_a_remote_get
+    end
+
+    it "should follow redirects from remote to local" do
+      driver.visit("#{REMOTE_TEST_URL}/redirect_to/http://www.local.com/host")
+      should_be_a_local_get
+    end
+
+    after do
+      Capybara.default_host = nil
+    end
+
+    it "should raise a useful error for sites that return a 404, because it is probably a misconfiguration" do
+      expect { 
+        driver.visit("http://iamreallysurethatthisdoesntexist.com/canttouchthis")
+      }.to raise_error(%r{Received the following error for a GET request to http://iamreallysurethatthisdoesntexist.com/canttouchthis:})
+    end
+  end
+
+  it "should include the right host when remote" do
+    driver.visit("#{REMOTE_TEST_URL}/host")
+    should_be_a_remote_get
+  end
+
+  describe '#reset!' do
+    before do
+      Capybara.default_host = 'http://www.local.com'
+    end
+
+    it 'should reset remote host' do
+      driver.visit("#{REMOTE_TEST_URL}/host")
+      should_be_a_remote_get
+      driver.reset!
+      driver.visit("/host")
+      should_be_a_local_get
+    end
+  end
+
+  def should_be_a_remote_get
+    driver.current_url.should include(REMOTE_TEST_URL)
+  end
+
+  def should_be_a_local_get
+    driver.current_url.should include("www.local.com")
+  end
+# 
+end

data/spec/driver/remote_mechanize_driver_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Capybara::Mechanize::Driver, 'remote' do
+  before do
+    Capybara.app_host = REMOTE_TEST_URL
+  end
+
+  after do
+    Capybara.app_host = nil
+  end
+
+  let(:driver) { Capybara::Mechanize::Driver.new(ExtendedTestApp) }
+
+  context "in remote mode" do
+    it "should pass arguments through to a get request" do
+      driver.visit("#{REMOTE_TEST_URL}/form/get", {:form => "success"})
+      driver.html.should include('success')
+    end
+
+    it "should pass arguments through to a post request" do
+      driver.post("#{REMOTE_TEST_URL}/form", {:form => "success"})
+      driver.html.should include('success')
+    end
+
+    describe "redirect" do
+      it "should handle redirects with http-params" do
+        driver.visit "#{REMOTE_TEST_URL}/redirect_with_http_param"
+        driver.html.should include('correct redirect')
+      end
+    end
+
+    context "for a post request" do
+      it 'transforms nested map in post data' do
+        driver.post("#{REMOTE_TEST_URL}/form", {:form => {:key => 'value'}})
+        driver.html.should include(':key=>"value"')
+      end
+    end
+
+    context 'process remote request' do
+      it 'transforms nested map in post data' do
+        driver.submit(:post, "#{REMOTE_TEST_URL}/form", {:form => {:key => 'value'}})
+        driver.html.should include(':key=>"value"')
+      end
+    end
+  end
+end

data/spec/session/mechanize_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module TestSessions
+  Mechanize = Capybara::Session.new(:mechanize, TestApp)
+end
+
+Capybara::SpecHelper.run_specs TestSessions::Mechanize, "Mechanize", :skip => [
+  :js,
+  :screenshot,
+  :frames,
+  :windows,
+  :server
+]
+
+describe Capybara::Session do
+  context 'with mechanize driver' do
+    let(:session) { Capybara::Session.new(:mechanize, ExtendedTestApp) }
+
+    before do
+      Capybara.default_host = 'http://www.local.com'
+    end
+
+    describe '#driver' do
+      it "should be a mechanize driver" do
+        session.driver.should be_an_instance_of(Capybara::Mechanize::Driver)
+      end
+    end
+
+    describe '#mode' do
+      it "should remember the mode" do
+        session.mode.should == :mechanize
+      end
+    end
+
+    describe '#click_link' do
+      it "should use data-method if option is true" do
+        session.driver.options[:respect_data_method] = true
+        session.visit "/with_html"
+        session.click_link "A link with data-method"
+        session.html.should include('The requested object was deleted')
+      end
+
+      it "should not use data-method if option is false" do
+        session.driver.options[:respect_data_method] = false
+        session.visit "/with_html"
+        session.click_link "A link with data-method"
+        session.html.should include('Not deleted')
+      end
+
+      it "should use data-method if available even if it's capitalized" do
+        session.driver.options[:respect_data_method] = true
+        session.visit "/with_html"
+        session.click_link "A link with capitalized data-method"
+        session.html.should include('The requested object was deleted')
+      end
+
+      after do
+        session.driver.options[:respect_data_method] = false
+      end
+    end
+
+    describe "#attach_file" do
+      context "with multipart form" do
+        it "should submit an empty form-data section if no file is submitted" do
+          session.visit("/form")
+          session.click_button("Upload Empty")
+          session.html.should include('Successfully ignored empty file field.')
+        end
+      end
+    end
+
+    it "should use the last remote url when following relative links" do
+      session.visit("#{REMOTE_TEST_URL}/relative_link_to_host")
+      session.click_link "host"
+      session.body.should include("Current host is #{REMOTE_TEST_URL}/request_info/host, method get")
+    end
+
+    it "should use the last remote url when submitting a form with a relative action" do
+      session.visit("#{REMOTE_TEST_URL}/form_with_relative_action_to_host")
+      session.click_button "submit"
+      session.body.should include("Current host is #{REMOTE_TEST_URL}/request_info/host, method post")
+    end
+
+    it "should use the last url when submitting a form with no action" do
+      session.visit("#{REMOTE_TEST_URL}/request_info/form_with_no_action")
+      session.click_button "submit"
+      session.body.should include("Current host is #{REMOTE_TEST_URL}/request_info/form_with_no_action, method post")
+    end
+
+    it "should send correct user agent" do
+      session.visit("#{REMOTE_TEST_URL}/request_info/user_agent")
+      session.body.should include("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.853.0 Safari/535.2")
+    end
+  end
+end

data/spec/session/remote_mechanize_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module TestSessions
+  Mechanize = Capybara::Session.new(:mechanize, TestApp)
+end
+
+shared_context "remote tests" do
+  before do
+    Capybara.app_host = REMOTE_TEST_URL
+  end
+
+  after do
+    Capybara.app_host = nil
+  end
+end
+
+session_describe = Capybara::SpecHelper.run_specs TestSessions::Mechanize, "Mechanize", :skip => [
+  :js,
+  :screenshot,
+  :frames,
+  :windows,
+  :server
+]
+
+session_describe.include_context("remote tests")
+
+disabler = DisableExternalTests.new
+disabler.tests_to_disable = [
+  ['#visit', 'when Capybara.always_include_port is true', 'should fetch a response from the driver with an absolute url without a port'],
+  ['#reset_session!', 'raises any errors caught inside the server']
+]
+disabler.disable(session_describe)
+
+describe Capybara::Session do
+  context 'with remote mechanize driver' do
+    include_context 'remote tests'
+
+    let(:session) { Capybara::Session.new(:mechanize, ExtendedTestApp) }
+
+    describe '#driver' do
+      it "should be a mechanize driver" do
+        session.driver.should be_an_instance_of(Capybara::Mechanize::Driver)
+      end
+    end
+
+    describe '#mode' do
+      it "should remember the mode" do
+        session.mode.should == :mechanize
+      end
+    end
+
+    describe '#click_link' do
+      it "should use data-method if option is true" do
+        session.driver.options[:respect_data_method] = true
+        session.visit "/with_html"
+        session.click_link "A link with data-method"
+        session.html.should include('The requested object was deleted')
+      end
+
+      it "should not use data-method if option is false" do
+        session.driver.options[:respect_data_method] = false
+        session.visit "/with_html"
+        session.click_link "A link with data-method"
+        session.html.should include('Not deleted')
+      end
+
+      it "should use data-method if available even if it's capitalized" do
+        session.driver.options[:respect_data_method] = true
+        session.visit "/with_html"
+        session.click_link "A link with capitalized data-method"
+        session.html.should include('The requested object was deleted')
+      end
+
+      after do
+        session.driver.options[:respect_data_method] = false
+      end
+    end
+
+    describe "#attach_file" do
+      context "with multipart form" do
+        it "should submit an empty form-data section if no file is submitted" do
+          session.visit("/form")
+          session.click_button("Upload Empty")
+          session.html.should include('Successfully ignored empty file field.')
+        end
+      end
+    end
+
+    context "remote app in a sub-path" do
+      it "follows relative link correctly" do
+        session.visit "/subsite/relative_link_to_host"
+        session.click_link "host"
+        session.body.should include('request_info2/host')
+      end
+
+      it "follows local link correctly" do
+        session.visit "/subsite/local_link_to_host"
+        session.click_link "host"
+        session.body.should include('request_info2/host')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'capybara/spec/spec_helper'
+require 'capybara/mechanize'
+require 'capybara/spec/extended_test_app'
+
+PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')).freeze
+
+$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
+
+Dir[File.join(PROJECT_ROOT, 'spec', 'support', '**', '*.rb')].each { |file| require(file) }
+
+RSpec.configure do |config|
+  # Spruce up the focus!
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  # Used with DisableExternalTests
+  config.filter_run_excluding :external_test_disabled
+
+  config.after do
+    Capybara::Mechanize.local_hosts = nil
+  end
+
+  Capybara::SpecHelper.configure(config)
+end
+
+setup = ExtendedTestAppSetup.new.boot
+REMOTE_TEST_URL = setup.remote_test_url

data/spec/support/disable_external_tests.rb

@@ -0,0 +1,20 @@
+class DisableExternalTests
+  attr_accessor :tests_to_disable
+
+  def disable(top_level_example_group)
+    tests_to_disable.each do |to_disable|
+      example_group = top_level_example_group
+
+      example_description = to_disable.pop
+
+      to_disable.each do |description|
+        example_group = example_group.children.select{ |g| g.description == description }.first
+      end
+
+      example = example_group.examples.select{ |e| e.description == example_description }.first
+
+      example.metadata[:external_test_disabled] = true
+    end
+
+  end
+end

data/spec/support/extended_test_app_setup.rb

@@ -0,0 +1,30 @@
+# This class works around some weirdness with Capybara's test suite and sinatra's behavior.
+# We need to make sure that sinatra uses TestApp for at least one request before the Capybara session
+# specs run.  Without this we get errors from sinatra trying to handle requests with TestApp.clone
+class ExtendedTestAppSetup
+  include Capybara::DSL
+
+  attr_reader :remote_test_url
+
+  def boot
+    boot_test_app
+    boot_remote_app
+
+    self
+  end
+
+  def boot_test_app
+    Capybara.app = TestApp
+    dummy_server = Capybara::Server.new(TestApp)
+    dummy_server.boot
+
+    # Boot TestApp's Sinatra
+    visit '/'
+  end
+
+  def boot_remote_app
+    remote_server = Capybara::Server.new(ExtendedTestApp)
+    remote_server.boot
+    @remote_test_url = "http://localhost:#{remote_server.port}"
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: ryansch-capybara-mechanize
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Jeroen van Dijk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+description: RackTest driver for Capybara, but with remote request support thanks
+  to mechanize
+email: jeroen@jeevidee.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/capybara/mechanize/browser.rb
+- lib/capybara/mechanize/cucumber.rb
+- lib/capybara/mechanize/driver.rb
+- lib/capybara/mechanize/form.rb
+- lib/capybara/mechanize/node.rb
+- lib/capybara/mechanize/version.rb
+- lib/capybara/mechanize.rb
+- lib/capybara/spec/extended_test_app.rb
+- spec/driver/mechanize_driver_spec.rb
+- spec/driver/remote_mechanize_driver_spec.rb
+- spec/session/mechanize_spec.rb
+- spec/session/remote_mechanize_spec.rb
+- spec/spec_helper.rb
+- spec/support/disable_external_tests.rb
+- spec/support/extended_test_app_setup.rb
+- README.mdown
+homepage: https://github.com/ryansch/capybara-mechanize
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 728688646484683167
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: RackTest driver for Capybara with remote request support
+test_files: []