mechanize 1.0.1.beta.20110107104205 → 2.0.pre.1

data/lib/mechanize/chain/ssl_resolver.rb

@@ -1,40 +0,0 @@
-class Mechanize
-  class Chain
-    class SSLResolver
-      include Mechanize::Handler
-
-      def initialize(ca_file, verify_callback, cert, key, pass)
-        @ca_file = ca_file
-        @verify_callback = verify_callback
-        @cert = cert
-        @key = key
-        @pass = pass
-      end
-
-      def handle(ctx, params)
-        uri       = params[:uri]
-        http_obj  = params[:connection]
-
-        ssl = nil
-        if http_obj.instance_variable_defined?(:@ssl_context)
-          ssl = http_obj.instance_variable_get(:@ssl_context)
-        end
-
-        if uri.scheme == 'https' && ! http_obj.started? && (ssl.nil? || ! ssl.frozen?)
-          http_obj.use_ssl = true
-          http_obj.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          if @ca_file
-            http_obj.ca_file = @ca_file
-            http_obj.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            http_obj.verify_callback = @verify_callback if @verify_callback
-          end
-          if @cert && @key
-            http_obj.cert = OpenSSL::X509::Certificate.new(::File.read(@cert))
-            http_obj.key  = OpenSSL::PKey::RSA.new(::File.read(@key), @pass)
-          end
-        end
-        super
-      end
-    end
-  end
-end

data/lib/mechanize/chain/uri_resolver.rb

@@ -1,75 +0,0 @@
-class Mechanize
-  class Chain
-    class URIResolver
-      include Mechanize::Handler
-
-      def initialize(scheme_handlers)
-        @scheme_handlers = scheme_handlers
-      end
-
-      def handle(ctx, params)
-        raise ArgumentError.new('uri must be specified') unless params[:uri]
-        params[:uri] = params[:uri].dup if params[:uri].is_a?(URI)
-        uri     = params[:uri]
-        referer = params[:referer]
-        unless uri.is_a?(URI)
-          uri = uri.to_s.strip.gsub(/[^#{0.chr}-#{126.chr}]/) { |match|
-            if RUBY_VERSION >= "1.9.0"
-              CGI.escape(match)
-            else
-              sprintf('%%%X', match.unpack($KCODE == 'UTF8' ? 'U' : 'c')[0])
-            end
-          }
-
-          escaped_uri = Util.html_unescape(
-                                           uri.split(/(?:%[0-9A-Fa-f]{2})+|#/).zip(
-                                                                                   uri.scan(/(?:%[0-9A-Fa-f]{2})+|#/)
-                                                                                   ).map { |x,y|
-                                             "#{WEBrick::HTTPUtils.escape(x)}#{y}"
-                                           }.join('')
-                                           )
-
-          begin
-            uri = URI.parse(escaped_uri)
-          rescue
-            uri = URI.parse(WEBrick::HTTPUtils.escape(escaped_uri))
-          end
-
-        end
-        uri = @scheme_handlers[
-                               uri.relative? ? 'relative' : uri.scheme.downcase
-                              ].call(uri, params[:referer])
-
-        if params[:referer] && params[:referer].uri
-          if uri.path.length == 0 && uri.relative?
-            uri.path = params[:referer].uri.path
-          end
-        end
-
-        uri.path = '/' if uri.path.length == 0
-
-        if uri.relative?
-          raise 'need absolute URL' unless referer && referer.uri
-          base = nil
-          if referer.respond_to?(:bases) && referer.parser
-            base = referer.bases.last
-          end
-
-          uri = ((base && base.uri && base.uri.absolute?) ?
-                 base.uri :
-                 referer.uri) + uri
-          uri = referer.uri + uri
-          # Strip initial "/.." bits from the path
-          uri.path.sub!(/^(\/\.\.)+(?=\/)/, '')
-        end
-
-        unless ['http', 'https', 'file'].include?(uri.scheme.downcase)
-          raise "unsupported scheme: #{uri.scheme}"
-        end
-        params[:uri] = uri
-
-        super
-      end
-    end
-  end
-end

data/test/chain/test_argument_validator.rb

@@ -1,14 +0,0 @@
-require "helper"
-
-class TestURIResolver < Test::Unit::TestCase
-  def test_handle
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::URIResolver.new(Hash.new { |h,k|
-        h[k] = lambda { |u,r| u }
-      })
-    ])
-    assert_raises(ArgumentError) { v.handle({}) }
-    assert_nothing_raised { v.handle({:uri => 'http://google.com/'}) }
-    assert_raises(RuntimeError) { v.handle({:uri => 'google'}) }
-  end
-end

data/test/chain/test_auth_headers.rb

@@ -1,25 +0,0 @@
-require "helper"
-
-class TestAuthHeaders < Test::Unit::TestCase
-  def test_auth
-    url = URI.parse('http://www.anthonychaves.net/tests.xml')
-    digest = %Q!Digest realm="www.anthonychaves.net", qop="auth", algorithm=MD5, nonce="MTI0NTEyMTYyNjo0ZTY2MjhlZWMyZmM1ZjA0M2Y1Njc1MGU0YTA2MWY5OQ==", opaque="9f455d4e71e8d46a6d3aaef8bf8b0d9e"!
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::AuthHeaders.new({(url.host) => :digest}, "anthony", "password", digest)
-    ])
-    
-    hash = {
-      :request => Net::HTTP::Get.new(url.request_uri),
-      :uri => url
-    }
-    v.handle(hash) 
-    actual_authorization = hash[:request]['Authorization'] 
-    # The chain gave our request an Authorization header with client-generated values and derivatives.
-    # They should be scrubbed before comparing to the expected result because they change
-    # on each invokation
-    actual_authorization.gsub!(/cnonce=\"\w+?\"/, "cnonce=\"scrubbed_cnonce\"").gsub!(/response=\"\w+?\"/, "response=\"scrubbed_response\"")
-    
-    expected_authorization = %Q!Digest username="anthony", qop=auth, uri="/tests.xml", algorithm="MD5", opaque="9f455d4e71e8d46a6d3aaef8bf8b0d9e", nonce="MTI0NTEyMTYyNjo0ZTY2MjhlZWMyZmM1ZjA0M2Y1Njc1MGU0YTA2MWY5OQ==", realm="www.anthonychaves.net", nc=00000001, cnonce="scrubbed_cnonce", response="scrubbed_response"!
-    assert_equal(expected_authorization, actual_authorization)
-  end
-end

data/test/chain/test_custom_headers.rb

@@ -1,18 +0,0 @@
-require "helper"
-
-class TestCustomHeaders < Test::Unit::TestCase
-  def test_handle
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::CustomHeaders.new
-    ])
-    url = URI.parse('http://tenderlovemaking.com/')
-    hash = {
-      :request => Net::HTTP::Get.new(url.request_uri),
-      :headers => { 'Content-Length' => 300 }
-    }
-    v.handle(hash)
-    headers = hash[:request].to_hash
-    assert(headers.key?('content-length'))
-    assert_equal([300], headers['content-length'])
-  end
-end

data/test/chain/test_header_resolver.rb

@@ -1,27 +0,0 @@
-require "helper"
-
-class TestHeaderResolver < Test::Unit::TestCase
-  def setup
-    @chain = Mechanize::Chain.new([
-      Mechanize::Chain::HeaderResolver.new(
-        Mechanize::CookieJar.new,
-        'foobar',
-        true,
-        {
-          'hello' => 'world',
-          'Content-Type' => 'utf-8'
-        }
-      )
-    ])
-  end
-
-  def test_handle
-    hash = {
-      :request => {},
-      :uri => URI.parse('http://google.com/')
-    }
-    @chain.handle(hash)
-    assert_equal 'world', hash[:request]['hello']
-    assert_equal 'utf-8', hash[:request]['Content-Type']
-  end
-end

data/test/chain/test_parameter_resolver.rb

@@ -1,35 +0,0 @@
-require "helper"
-
-class TestParameterResolver < Test::Unit::TestCase
-  def test_handle_get
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::ParameterResolver.new
-    ])
-    hash = {
-      :uri    => URI.parse('http://google.com/'),
-      :params => { :q => 'hello' },
-      :verb   => :get
-    }
-    assert_nothing_raised {
-      v.handle(hash)
-    }
-    assert_equal('q=hello', hash[:uri].query)
-    assert_nil(hash[:params])
-  end
-
-  def test_handle_post
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::ParameterResolver.new
-    ])
-    hash = {
-      :uri    => URI.parse('http://google.com/'),
-      :params => { :q => 'hello' },
-      :verb   => :post
-    }
-    assert_nothing_raised {
-      v.handle(hash)
-    }
-    assert_equal('', hash[:uri].query.to_s)
-    assert_equal({ :q => 'hello' }, hash[:params])
-  end
-end

data/test/chain/test_request_resolver.rb

@@ -1,29 +0,0 @@
-require "helper"
-
-class TestRequestResolver < Test::Unit::TestCase
-  def test_handle_get
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::RequestResolver.new
-    ])
-    hash = {
-      :uri  => URI.parse('http://google.com'),
-      :verb => :get
-    }
-    assert_nothing_raised { v.handle(hash) }
-    assert_kind_of(Net::HTTP::Get, hash[:request])
-    assert_equal('/', hash[:request].path)
-  end
-
-  def test_handle_post
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::RequestResolver.new
-    ])
-    hash = {
-      :uri  => URI.parse('http://google.com'),
-      :verb => :post
-    }
-    assert_nothing_raised { v.handle(hash) }
-    assert_kind_of(Net::HTTP::Post, hash[:request])
-    assert_equal('/', hash[:request].path)
-  end
-end

data/test/chain/test_response_reader.rb

@@ -1,24 +0,0 @@
-require "helper"
-
-class TestResponseReader < Test::Unit::TestCase
-  def test_handle_bad_response_code
-    response = Object.new
-    class << response
-      def read_body
-      end
-      def code; 999; end
-    end
-
-    v = Mechanize::Chain.new([
-      Mechanize::Chain::ResponseReader.new(response)
-    ])
-    assert_raises(Mechanize::ResponseCodeError) {
-      begin
-        v.handle({})
-      rescue Exception => x
-        assert_equal(999, x.response_code)
-        raise x
-      end
-    }
-  end
-end

data/test/test_cookie_jar.rb

@@ -1,324 +0,0 @@
-require "helper"
-
-class CookieJarTest < Test::Unit::TestCase
-  def cookie_values(options = {})
-    {
-      :name     => 'Foo',
-      :value    => 'Bar',
-      :path     => '/',
-      :expires  => Time.now + (10 * 86400),
-      :domain   => 'rubyforge.org'
-   }.merge(options)
-  end
-
-  def cookie_from_hash(hash)
-    c = Mechanize::Cookie.new(hash[:name], hash[:value])
-    hash.each { |k,v|
-      next if k == :name || k == :value
-      c.send("#{k}=", v)
-    }
-    c
-  end
-
-  def test_two_cookies_same_domain_and_name_different_paths
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    jar.add(url, cookie_from_hash(cookie_values(:path => '/onetwo')))
-
-    assert_equal(1, jar.cookies(url).length)
-    assert_equal 2, jar.cookies(URI.parse('http://rubyforge.org/onetwo')).length
-  end
-
-  def test_domain_case
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length)
-
-    jar.add(url, cookie_from_hash(
-        cookie_values(:domain => 'RuByForge.Org', :name   => 'aaron')))
-
-    assert_equal(2, jar.cookies(url).length)
-
-    url2 = URI.parse('http://RuByFoRgE.oRg/')
-    assert_equal(2, jar.cookies(url2).length)
-  end
-
-  def test_empty_value
-    values = cookie_values(:value => "")
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length)
-
-    jar.add(url, cookie_from_hash( values.merge(  :domain => 'RuByForge.Org',
-                                                  :name   => 'aaron'
-                                               ) ) )
-
-    assert_equal(2, jar.cookies(url).length)
-
-    url2 = URI.parse('http://RuByFoRgE.oRg/')
-    assert_equal(2, jar.cookies(url2).length)
-  end
-
-  def test_add_future_cookies
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length)
-
-    # Add the same cookie, and we should still only have one
-    jar.add(url, cookie_from_hash(cookie_values))
-    assert_equal(1, jar.cookies(url).length)
-
-    # Make sure we can get the cookie from different paths
-    assert_equal(1, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
-
-    # Make sure we can't get the cookie from different domains
-    assert_equal(0, jar.cookies(URI.parse('http://google.com/')).length)
-  end
-
-  def test_add_multiple_cookies
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length)
-
-    # Add the same cookie, and we should still only have one
-    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
-    assert_equal(2, jar.cookies(url).length)
-
-    # Make sure we can get the cookie from different paths
-    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
-
-    # Make sure we can't get the cookie from different domains
-    assert_equal(0, jar.cookies(URI.parse('http://google.com/')).length)
-  end
-
-  def test_clear_cookies
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
-    assert_equal(2, jar.cookies(url).length)
-
-    jar.clear!
-
-    assert_equal(0, jar.cookies(url).length)
-  end
-
-  def test_save_cookies
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
-    assert_equal(2, jar.cookies(url).length)
-
-    jar.save_as("cookies.yml")
-    jar.clear!
-    assert_equal(0, jar.cookies(url).length)
-
-    jar.load("cookies.yml")
-    assert_equal(2, jar.cookies(url).length)
-    FileUtils.rm("cookies.yml")
-  end
-
-  def test_expire_cookies
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length)
-
-    # Add a second cookie
-    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
-    assert_equal(2, jar.cookies(url).length)
-
-    # Make sure we can get the cookie from different paths
-    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
-
-    # Expire the first cookie
-    jar.add(url, cookie_from_hash(
-        cookie_values(:expires => Time.now - (10 * 86400))))
-    assert_equal(1, jar.cookies(url).length)
-
-    # Expire the second cookie
-    jar.add(url, cookie_from_hash(
-        cookie_values( :name => 'Baz', :expires => Time.now - (10 * 86400))))
-    assert_equal(0, jar.cookies(url).length)
-  end
-
-  def test_session_cookies
-    values = cookie_values(:expires => nil)
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length)
-
-    # Add a second cookie
-    jar.add(url, cookie_from_hash(values.merge(:name => 'Baz')))
-    assert_equal(2, jar.cookies(url).length)
-
-    # Make sure we can get the cookie from different paths
-    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
-
-    # Expire the first cookie
-    jar.add(url, cookie_from_hash(values.merge(:expires => Time.now - (10 * 86400))))
-    assert_equal(1, jar.cookies(url).length)
-
-    # Expire the second cookie
-    jar.add(url, cookie_from_hash(
-        values.merge(:name => 'Baz', :expires => Time.now - (10 * 86400))))
-    assert_equal(0, jar.cookies(url).length)
-
-    # When given a URI with a blank path, CookieJar#cookies should return
-    # cookies with the path '/':
-    url = URI.parse('http://rubyforge.org')
-    assert_equal '', url.path
-    assert_equal(0, jar.cookies(url).length)
-    # Now add a cookie with the path set to '/':
-    jar.add(url, cookie_from_hash(values.merge( :name => 'has_root_path',
-                                          :path => '/')))
-    assert_equal(1, jar.cookies(url).length)
-  end
-
-  def test_paths
-    values = cookie_values(:path => "/login", :expires => nil)
-    url = URI.parse('http://rubyforge.org/login')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length)
-
-    # Add a second cookie
-    jar.add(url, cookie_from_hash(values.merge( :name => 'Baz' )))
-    assert_equal(2, jar.cookies(url).length)
-
-    # Make sure we don't get the cookie in a different path
-    assert_equal(0, jar.cookies(URI.parse('http://rubyforge.org/hello')).length)
-    assert_equal(0, jar.cookies(URI.parse('http://rubyforge.org/')).length)
-
-    # Expire the first cookie
-    jar.add(url, cookie_from_hash(values.merge( :expires => Time.now - (10 * 86400))))
-    assert_equal(1, jar.cookies(url).length)
-
-    # Expire the second cookie
-    jar.add(url, cookie_from_hash(values.merge( :name => 'Baz',
-                                          :expires => Time.now - (10 * 86400))))
-    assert_equal(0, jar.cookies(url).length)
-  end
-
-
-  def test_save_and_read_cookiestxt
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    jar.add(url, cookie)
-    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
-    assert_equal(2, jar.cookies(url).length)
-
-    jar.save_as("cookies.txt", :cookiestxt)
-    jar.clear!
-    assert_equal(0, jar.cookies(url).length)
-
-    jar.load("cookies.txt", :cookiestxt)
-    assert_equal(2, jar.cookies(url).length)
-
-    FileUtils.rm("cookies.txt")
-  end
-
-  def test_save_and_read_cookiestxt_with_session_cookies
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-
-    jar.add(url, cookie_from_hash(cookie_values(:expires => nil)))
-    jar.save_as("cookies.txt", :cookiestxt)
-    jar.clear!
-    assert_equal(0, jar.cookies(url).length)
-
-    jar.load("cookies.txt", :cookiestxt)
-    assert_equal(1, jar.cookies(url).length)
-    assert_nil jar.cookies(url).first.expires
-    FileUtils.rm("cookies.txt")
-  end
-
-  def test_save_and_read_expired_cookies
-    url = URI.parse('http://rubyforge.org/')
-
-    jar = Mechanize::CookieJar.new
-    jar.jar['rubyforge.org'] = {}
-
-    assert_nothing_raised do
-      jar.add(url, cookie_from_hash(cookie_values))
-    end
-  end
-
-  def test_ssl_cookies
-    # thanks to michal "ocher" ochman for reporting the bug responsible for this test.
-    values = cookie_values(:expires => nil)
-    values_ssl = values.merge(:domain => "#{values[:domain]}:443")
-    url = URI.parse('https://rubyforge.org/login')
-
-    jar = Mechanize::CookieJar.new
-    assert_equal(0, jar.cookies(url).length)
-
-    cookie = cookie_from_hash(values)
-    jar.add(url, cookie)
-    assert_equal(1, jar.cookies(url).length, "did not handle SSL cookie")
-
-    cookie = cookie_from_hash(values_ssl)
-    jar.add(url, cookie)
-    assert_equal(2, jar.cookies(url).length, "did not handle SSL cookie with :443")
-  end
-end