bbc-capybara-mechanize-with-proxy 0.3.0.rc0

data/README.mdown

@@ -0,0 +1,89 @@
+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.
+
+### Mechanize using proxy
+
+If you are behind a proxy, you can specify an PROXY=ON ENV variable on the command line and setup mechanize to use proxy or not as below:
+
+	Capybara.register_driver :mechanize do |app|
+  		Capybara.app_host = "http://www.yourapp.com"
+  		if ENV['PROXY'] == 'ON'
+  			Capybara::Mechanize::Driver.new(app,{:proxy =>"http://yourproxy.com"})
+  		else
+  			Capybara::Mechanize::Driver.new(app)
+  		end
+	end
+	
+## Running tests
+
+Until this library is merged with capybara there needs to be local app and you need to add the following to your host file:
+
+    127.0.0.1 capybara-testapp.heroku.com 
+
+Run bundler
+
+    bundle install
+
+Run the app with the following line: 
+
+    bundle exec ruby -rrubygems lib/capybara/spec/extended_test_app.rb
+
+Then you are ready to run the test like so
+
+    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 Jeroen van Dijk. See LICENSE for details.

data/lib/capybara/mechanize/browser.rb

@@ -0,0 +1,235 @@
+require 'capybara/rack_test/driver'
+require 'mechanize'
+
+class Capybara::Mechanize::Browser < Capybara::RackTest::Browser
+  extend Forwardable
+  
+  def_delegator :agent, :scheme_handlers
+  def_delegator :agent, :scheme_handlers=
+  
+  def initialize(app, options)
+    @agent = ::Mechanize.new
+    @agent.redirect_ok = false
+	if !options.empty?
+		if options[:proxy] && !options[:proxy].empty?
+			proxy = nil
+			begin
+				proxy = URI.parse(options[:proxy])
+			rescue URI::InvalidURIError => e
+				raise "You have entered an invalid proxy address #{options[:proxy]}. Check proxy settings."
+			end
+			if proxy && proxy.instance_of?(URI::HTTP) 
+				@agent.set_proxy(proxy.host, proxy.port)
+			else
+				raise "ProxyError: You have entered an invalid proxy address #{options[:proxy]}. e.g. (http|https)://proxy.com(:port)"
+			end
+		end
+	end
+    super
+  end
+  
+  def reset_host!
+    @last_remote_host = 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
+  
+  def follow_redirects!
+    5.times do
+      follow_redirect! if last_response.redirect?
+    end
+    raise Capybara::InfiniteRedirectError, "redirected more than 5 times, check for infinite redirects." if last_response.redirect?
+  end
+  
+  def follow_redirect!
+    unless last_response.redirect?
+      raise "Last response was not a redirect. Cannot follow_redirect!"
+    end
+  
+    get(last_location_header)
+  end
+  
+  def process(method, path, *options)
+    reset_cache!
+    send(method, path, *options)
+    follow_redirects!
+  end
+  
+  def process_without_redirect(method, path, attributes, headers)
+    path = @last_path if path.nil? || path.empty?
+
+    if remote?(path)
+      process_remote_request(method, path, attributes, headers)
+    else
+      register_local_request
+      
+      path = determine_path(path)
+      
+      reset_cache!
+      send("racktest_#{method}", path, attributes, env.merge(headers))
+    end
+    
+    @last_path = path
+  end
+  
+  # TODO path Capybara to move this into its own method
+  def determine_path(path)
+    new_uri = URI.parse(path)
+    current_uri = URI.parse(current_url)
+
+    if new_uri.host
+      @current_host = new_uri.scheme + '://' + new_uri.host
+    end
+  
+    if new_uri.relative?
+      path = request_path + path if path.start_with?('?')
+    
+      unless path.start_with?('/')
+        folders = request_path.split('/')
+        path = (folders[0, folders.size - 1] << path).join('/')
+      end
+      path = current_host + path
+    end
+    path
+  end
+
+  alias :racktest_get :get
+  def get(path, attributes = {}, headers = {})
+    process_without_redirect(:get, path, attributes, headers)
+  end
+
+  alias :racktest_post :post
+  def post(path, attributes = {}, headers = {})
+    process_without_redirect(:post, path, post_data(attributes), headers)
+  end
+  
+  alias :racktest_put :put
+  def put(path, attributes = {}, headers = {})
+    process_without_redirect(:put, path, attributes, headers)
+  end
+  
+  alias :racktest_delete :delete
+  def delete(path, attributes = {}, headers = {})
+    process_without_redirect(:delete, path, attributes, headers)
+  end
+  
+  def post_data(params)
+    params.inject({}) do |memo, param|
+      case param
+      when Hash
+        param.each {|attribute, value| memo[attribute] = value }
+        memo
+      when Array
+        case param.last
+        when Hash
+          param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
+        else
+          memo[param.first] = param.last
+        end
+        memo
+      end
+    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
+  
+  attr_reader :agent
+  
+  private
+  
+  def last_location_header
+    last_request_remote? ? remote_response.page.response['Location'] : last_response['Location']
+  end
+  
+  def last_request_remote?
+    !!@last_request_remote
+  end
+  
+  def register_local_request
+    @last_remote_host = nil
+    @last_request_remote = false
+  end
+  
+  def process_remote_request(method, url, attributes, headers)
+    if remote?(url)
+      remote_uri = URI.parse(url)
+  
+      if remote_uri.host.nil?
+        remote_host = @last_remote_host || Capybara.app_host || Capybara.default_host
+        url = File.join(remote_host, url)
+        url = "http://#{url}" unless url =~ /^http:/
+      else
+        @last_remote_host = "#{remote_uri.host}:#{remote_uri.port}"
+      end
+      
+      reset_cache!
+      begin
+        args = []
+        args << attributes unless attributes.empty?
+        args << headers unless headers.empty?
+        @agent.send(method, url, *args)
+      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 remote_response
+    ResponseProxy.new(@agent.current_page) if @agent.current_page
+  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 status
+      page.code.to_i
+    end    
+  
+    def redirect?
+      [301, 302].include?(status)
+    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,21 @@
+require 'capybara/mechanize/browser'
+
+class Capybara::Mechanize::Driver < Capybara::RackTest::Driver
+  
+  def initialize(app = nil, options = {})
+    if !app && !Capybara.app_host
+      raise ArgumentError, "You have to set at least Capybara.app_host or Capybara.app"
+    end
+
+    @app, @options = app, options
+  end
+
+  def remote?(url)
+    browser.remote?(url)
+  end
+  
+  def browser
+    @browser ||= Capybara::Mechanize::Browser.new(app, options)
+  end
+  
+end

data/lib/capybara/mechanize/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module Mechanize
+    VERSION = '0.3.0.rc0'
+  end
+end

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, options = {})
+end

data/lib/capybara/spec/extended_test_app.rb

@@ -0,0 +1,41 @@
+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!
+  
+  get %r{/redirect_to/(.*)} do
+    redirect params[:captures]
+  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/*' do
+    current_request_info
+  end
+
+  post '/request_info/*' do
+    current_request_info
+  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,151 @@
+require 'spec_helper'
+
+describe "Capybara::Driver::Mechanize, in local model" do
+  before do
+    @driver = Capybara::Mechanize::Driver.new(ExtendedTestApp)
+  end
+  
+  it "should throw an error when no rack app is given without an app host" do
+    running do
+      Capybara::Mechanize::Driver.new
+    end.should raise_error(ArgumentError, "You have to set at least Capybara.app_host or Capybara.app")
+  end
+  
+  it_should_behave_like "driver"
+  it_should_behave_like "driver with header support"
+  it_should_behave_like "driver with status code support"
+  it_should_behave_like "driver with cookies support"
+  it_should_behave_like "driver with infinite redirect detection"
+
+  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 :each 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 :each 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
+      lambda { 
+        @driver.visit("http://iamreallysurethatthisdoesntexist.com/canttouchthis")
+      }.should 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 :each 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.body.should include(REMOTE_TEST_URL)
+  end
+  
+  def should_be_a_local_get
+    @driver.body.should include("www.local.com")
+  end
+
+end

data/spec/driver/remote_mechanize_driver_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Capybara::Mechanize::Driver do
+  before(:each) do
+    Capybara.app_host = REMOTE_TEST_URL
+  end
+  
+  after(:each) do
+    Capybara.app_host = nil
+  end
+
+  before do
+    @driver = Capybara::Mechanize::Driver.new
+  end
+  
+  context "in remote mode" do
+    it "should not throw an error when no rack app is given" do
+      running do
+        Capybara::Mechanize::Driver.new
+      end.should_not raise_error(ArgumentError)
+    end
+    
+    it "should pass arguments through to a get request" do
+      @driver.visit("#{REMOTE_TEST_URL}/form/get", {:form => "success"})
+      @driver.body.should include('success')
+    end
+
+    it "should pass arguments through to a post request" do
+      @driver.post("#{REMOTE_TEST_URL}/form", {:form => "success"})
+      @driver.body.should include('success')
+    end
+
+    context "for a post request" do
+
+      it "should transform nested map in post data" do
+        @driver.post("#{REMOTE_TEST_URL}/form", {:form => {:key => "value"}})
+        @driver.body.should include('key: value')
+      end
+
+    end
+
+    context "process remote request" do
+
+      it "should transform nested map in post data" do
+        @driver.submit(:post, "#{REMOTE_TEST_URL}/form", {:form => {:key => "value"}})
+        @driver.body.should include('key: value')
+      end
+
+    end
+
+    it_should_behave_like "driver"
+    it_should_behave_like "driver with header support"
+    it_should_behave_like "driver with status code support"
+    it_should_behave_like "driver with cookies support"
+    it_should_behave_like "driver with infinite redirect detection"
+  end
+  
+end
+
+describe "Capybara::Mechanize::Driver, browser" do
+  before(:each) do
+    Capybara.app_host = REMOTE_TEST_URL
+  end
+  
+  after(:each) do
+    Capybara.app_host = nil
+  end
+    context "in remote mode" do
+  		it "should not throw an error when empty option is passed" do
+      		running do
+        		Capybara::Mechanize::Driver.new(ExtendedTestApp, {})
+      		end.should_not raise_error()
+    	end
+    	
+    	it "should throw an error when bad proxy option is passed" do
+      		running do
+        		Capybara::Mechanize::Driver.new(ExtendedTestApp, {:proxy => BAD_PROXY}).browser
+      		end.should raise_error("ProxyError: You have entered an invalid proxy address #{BAD_PROXY}. e.g. (http|https)://proxy.com(:port)")
+    	end
+    	
+    	it "should not throw an error when good proxy option is passed" do
+      		running do
+        		Capybara::Mechanize::Driver.new(ExtendedTestApp, {:proxy => GOOD_PROXY}).browser
+      		end.should_not raise_error()
+    	end
+    	
+    	it "should not throw an error when good proxy with port option is passed" do
+      		running do
+        		Capybara::Mechanize::Driver.new(ExtendedTestApp, {:proxy => PROXY_WITH_PORT}).browser
+      		end.should_not raise_error()
+    	end
+    	
+    	
+  	end
+end

data/spec/session/mechanize_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Capybara::Session do
+  context 'with mechanize driver' do
+    before do
+      @session = Capybara::Session.new(:mechanize, TestApp)
+      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 available" do
+        @session.visit "/with_html"
+        @session.click_link "A link with data-method"
+        @session.body.should include('The requested object was deleted')
+      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_behave_like "session"
+    it_should_behave_like "session without javascript support"
+    it_should_behave_like "session with headers support"
+    it_should_behave_like "session with status code support"
+  end
+end

data/spec/session/remote_mechanize_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Capybara::Session do
+  context 'with remote mechanize driver' do
+    before(:each) do
+      Capybara.app_host = REMOTE_TEST_URL
+    end
+
+    after(:each) do
+      Capybara.app_host = nil
+    end
+    
+    
+    before do      
+      @session = Capybara::Session.new(:mechanize)
+    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 available" do
+        @session.visit "/with_html"
+        @session.click_link "A link with data-method"
+        @session.body.should include('The requested object was deleted')
+      end
+    end
+
+    # Pending: Still 16 failing tests here (result is 706 examples, 16 failures, instead of 385 examples)
+    # it_should_behave_like "session"
+
+    it_should_behave_like "session without javascript support"
+    it_should_behave_like "session with headers support"
+    it_should_behave_like "session with status code support"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'bundler/setup'
+require 'capybara'
+require 'capybara/mechanize'
+require 'artifice'
+
+require 'sinatra'
+
+require 'capybara/spec/extended_test_app'
+
+# TODO move this stuff into capybara
+require 'capybara/spec/driver'
+require 'capybara/spec/session'
+
+alias :running :lambda
+
+Capybara.default_wait_time = 0 # less timeout so tests run faster
+
+RSpec.configure do |config|
+  config.before(:all) do
+    Artifice.activate_with(ExtendedTestApp)
+  end
+
+  config.after do
+    Capybara.default_selector = :xpath
+    Capybara::Mechanize.local_hosts = nil
+  end
+
+  config.after(:all) do
+    Artifice.deactivate
+  end
+  # config.filter_run :focus => true
+end
+
+REMOTE_TEST_URL = "http://localhost"
+GOOD_PROXY = "http://proxy.com"
+BAD_PROXY = "fasfasfasfasf"
+PROXY_WITH_PORT = "http://proxy.com:520"

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: bbc-capybara-mechanize-with-proxy
+version: !ruby/object:Gem::Version 
+  hash: 15424037
+  prerelease: 6
+  segments: 
+  - 0
+  - 3
+  - 0
+  - rc
+  - 0
+  version: 0.3.0.rc0
+platform: ruby
+authors: 
+- Jeroen van Dijk
+- Matthew Crouch
+- Voke Ransom Anighoro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: capybara
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+description: RackTest driver for Capybara, but with remote request support thanks to mechanize and added proxy configuration features
+email: ransom4real@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/capybara/mechanize/browser.rb
+- lib/capybara/mechanize/cucumber.rb
+- lib/capybara/mechanize/driver.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
+- README.mdown
+homepage: https://github.com/ransom4real/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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: RackTest driver for Capybara with remote request support
+test_files: []
+