benschwarz-smoke 0.4.2 → 0.5.0

data/vendor/fakeweb/test/test_fake_web_open_uri.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestFakeWebOpenURI < Test::Unit::TestCase
+
+  def test_content_for_registered_uri
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
+    assert_equal 'test example content', FakeWeb.response_for(:get, 'http://mock/test_example.txt').body
+  end
+  
+  def test_mock_open
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
+    assert_equal 'test example content', open('http://mock/test_example.txt').read
+  end
+  
+  def test_mock_open_with_string_as_registered_uri
+    FakeWeb.register_uri(:get, 'http://mock/test_string.txt', :body => 'foo')
+    assert_equal 'foo', open('http://mock/test_string.txt').string
+  end
+  
+  def test_real_open
+    FakeWeb.allow_net_connect = true
+    setup_expectations_for_real_apple_hot_news_request
+    resp = open('http://images.apple.com/main/rss/hotnews/hotnews.rss')
+    assert_equal "200", resp.status.first
+    body = resp.read
+    assert body.include?('Apple')
+    assert body.include?('News')
+  end
+  
+  def test_mock_open_that_raises_exception
+    FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => StandardError)
+    assert_raises(StandardError) do
+      open('http://mock/raising_exception.txt')
+    end
+  end
+
+  def test_mock_open_that_raises_an_http_error
+    FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => OpenURI::HTTPError)
+    assert_raises(OpenURI::HTTPError) do
+      open('http://mock/raising_exception.txt')
+    end
+  end
+
+  def test_mock_open_that_raises_an_http_error_with_a_specific_status
+    FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => OpenURI::HTTPError, :status => ['123', 'jodel'])
+    exception = assert_raises(OpenURI::HTTPError) do
+      open('http://mock/raising_exception.txt')
+    end
+    assert_equal '123', exception.io.code
+    assert_equal 'jodel', exception.io.message
+  end
+
+  def test_mock_open_with_block
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
+    body = open('http://mock/test_example.txt') { |f| f.readlines }
+    assert_equal 'test example content', body.first
+  end
+end

data/vendor/fakeweb/test/test_helper.rb

@@ -0,0 +1,74 @@
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'test/unit'
+require 'open-uri'
+require 'fake_web'
+require 'rubygems'
+require 'mocha'
+
+
+# Give all tests a common setup and teardown that prevents shared state
+class Test::Unit::TestCase
+  def setup
+    FakeWeb.clean_registry
+    @original_allow_net_connect = FakeWeb.allow_net_connect?
+    FakeWeb.allow_net_connect = false
+  end
+
+  def teardown
+    FakeWeb.allow_net_connect = @original_allow_net_connect
+  end
+end
+
+
+module FakeWebTestHelper
+
+  def capture_stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.rewind && $stderr.read
+  ensure
+    $stderr = STDERR
+  end
+
+  # Sets several expectations (using Mocha) that a real HTTP request makes it
+  # past FakeWeb to the socket layer. You can use this when you need to check
+  # that a request isn't handled by FakeWeb.
+  def setup_expectations_for_real_request(options = {})
+    # Socket handling
+    if options[:port] == 443
+      socket = mock("SSLSocket")
+      OpenSSL::SSL::SSLSocket.expects(:===).with(socket).returns(true).at_least_once
+      OpenSSL::SSL::SSLSocket.expects(:new).with(socket, instance_of(OpenSSL::SSL::SSLContext)).returns(socket).at_least_once
+      socket.stubs(:sync_close=).returns(true)
+      socket.expects(:connect).with().at_least_once
+    else
+      socket = mock("TCPSocket")
+      Socket.expects(:===).with(socket).returns(true)
+    end
+
+    TCPSocket.expects(:open).with(options[:host], options[:port]).returns(socket).at_least_once
+    socket.stubs(:closed?).returns(false)
+    socket.stubs(:close).returns(true)
+
+    # Request/response handling
+    request_parts = ["#{options[:method]} #{options[:path]} HTTP/1.1", "Host: #{options[:host]}"]
+    socket.expects(:write).with(all_of(includes(request_parts[0]), includes(request_parts[1]))).returns(100)
+
+    socket.expects(:sysread).at_least_once.returns("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\nContent-Length: #{options[:response_body].length}\n\n#{options[:response_body]}").then.raises(EOFError)
+  end
+
+
+  # A helper that calls #setup_expectations_for_real_request for you, using
+  # defaults for our commonly used test request to images.apple.com.
+  def setup_expectations_for_real_apple_hot_news_request(options = {})
+    defaults = { :host => "images.apple.com", :port => 80, :method => "GET",
+                 :path => "/main/rss/hotnews/hotnews.rss",
+                 :response_code => 200, :response_message => "OK",
+                 :response_body => "<title>Apple Hot News</title>" }
+    setup_expectations_for_real_request(defaults.merge(options))
+  end
+
+end
+
+Test::Unit::TestCase.send(:include, FakeWebTestHelper)

data/vendor/fakeweb/test/test_missing_open_uri.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestMissingOpenURI < Test::Unit::TestCase
+
+  def setup
+    super
+    @saved_open_uri = OpenURI
+    Object.send(:remove_const, :OpenURI)
+  end
+
+  def teardown
+    super
+    Object.const_set(:OpenURI, @saved_open_uri)
+  end
+
+
+  def test_register_using_exception_without_open_uri
+    # regression test for Responder needing OpenURI::HTTPError to be defined
+    FakeWeb.register_uri(:get, "http://example.com/", :exception => StandardError)
+    assert_raises(StandardError) do
+      Net::HTTP.start("example.com") { |http| http.get("/") }
+    end
+  end
+
+end

data/vendor/fakeweb/test/test_precedence.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestPrecedence < Test::Unit::TestCase
+
+  def test_matching_get_strings_have_precedence_over_matching_get_regexes
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "string")
+    FakeWeb.register_uri(:get, %r|http://example\.com/test|, :body => "regex")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "string", response.body
+  end
+
+  def test_matching_any_strings_have_precedence_over_matching_any_regexes
+    FakeWeb.register_uri(:any, "http://example.com/test", :body => "string")
+    FakeWeb.register_uri(:any, %r|http://example\.com/test|, :body => "regex")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "string", response.body
+  end
+
+  def test_matching_get_strings_have_precedence_over_matching_any_strings
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "get method")
+    FakeWeb.register_uri(:any, "http://example.com/test", :body => "any method")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "get method", response.body
+
+    # registration order should not matter
+    FakeWeb.register_uri(:any, "http://example.com/test2", :body => "any method")
+    FakeWeb.register_uri(:get, "http://example.com/test2", :body => "get method")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test2') }
+    assert_equal "get method", response.body
+  end
+
+  def test_matching_any_strings_have_precedence_over_matching_get_regexes
+    FakeWeb.register_uri(:any, "http://example.com/test", :body => "any string")
+    FakeWeb.register_uri(:get, %r|http://example\.com/test|, :body => "get regex")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "any string", response.body
+  end
+
+  def test_registered_strings_and_uris_are_equivalent_so_second_takes_precedence
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "string")
+    FakeWeb.register_uri(:get, URI.parse("http://example.com/test"), :body => "uri")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "uri", response.body
+
+    FakeWeb.register_uri(:get, URI.parse("http://example.com/test2"), :body => "uri")
+    FakeWeb.register_uri(:get, "http://example.com/test2", :body => "string")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test2') }
+    assert_equal "string", response.body
+  end
+
+end

data/vendor/fakeweb/test/test_query_string.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestFakeWebQueryString < Test::Unit::TestCase
+
+  def test_register_uri_string_with_query_params
+    FakeWeb.register_uri(:get, 'http://example.com/?a=1&b=1', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/?a=1&b=1')
+
+    FakeWeb.register_uri(:post, URI.parse("http://example.org/?a=1&b=1"), :body => "foo")
+    assert FakeWeb.registered_uri?(:post, "http://example.org/?a=1&b=1")
+  end
+
+  def test_register_uri_with_query_params_and_check_in_different_order
+    FakeWeb.register_uri(:get, 'http://example.com/?a=1&b=1', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/?b=1&a=1')
+
+    FakeWeb.register_uri(:post, URI.parse('http://example.org/?a=1&b=1'), :body => 'foo')
+    assert FakeWeb.registered_uri?(:post, 'http://example.org/?b=1&a=1')
+  end
+
+  def test_registered_uri_gets_recognized_with_empty_query_params
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/?')
+
+    FakeWeb.register_uri(:post, URI.parse('http://example.org/'), :body => 'foo')
+    assert FakeWeb.registered_uri?(:post, 'http://example.org/?')
+  end
+
+  def test_register_uri_with_empty_query_params_and_check_with_none
+    FakeWeb.register_uri(:get, 'http://example.com/?', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/')
+
+    FakeWeb.register_uri(:post, URI.parse('http://example.org/?'), :body => 'foo')
+    assert FakeWeb.registered_uri?(:post, 'http://example.org/')
+  end
+
+  def test_registry_sort_query_params
+    assert_equal "a=1&b=2", FakeWeb::Registry.instance.send(:sort_query_params, "b=2&a=1")
+  end
+
+  def test_registry_sort_query_params_sorts_by_value_if_keys_collide
+    assert_equal "a=1&a=2&b=2", FakeWeb::Registry.instance.send(:sort_query_params, "a=2&b=2&a=1")
+  end
+
+end

data/vendor/fakeweb/test/test_regexes.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestRegexes < Test::Unit::TestCase
+
+  def test_registered_uri_with_pattern
+    FakeWeb.register_uri(:get, %r|http://example.com/test_example/\d+|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/test_example/25")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/test_example/abc")
+  end
+
+  def test_response_for_with_matching_registered_uri
+    FakeWeb.register_uri(:get, %r|http://www.google.com|, :body => "Welcome to Google!")
+    assert_equal "Welcome to Google!", FakeWeb.response_for(:get, "http://www.google.com").body
+  end
+
+  def test_response_for_with_matching_registered_uri_and_get_method_matching_to_any_method
+    FakeWeb.register_uri(:any, %r|http://www.example.com|, :body => "example")
+    assert_equal "example", FakeWeb.response_for(:get, "http://www.example.com").body
+  end
+
+  def test_registered_uri_with_authentication_and_pattern
+    FakeWeb.register_uri(:get, %r|http://user:pass@mock/example\.\w+|i, :body => "example")
+    assert FakeWeb.registered_uri?(:get, 'http://user:pass@mock/example.txt')
+  end
+
+  def test_registered_uri_with_authentication_and_pattern_handles_case_insensitivity
+    FakeWeb.register_uri(:get, %r|http://user:pass@mock/example\.\w+|i, :body => "example")
+    assert FakeWeb.registered_uri?(:get, 'http://uSeR:PAss@mock/example.txt')
+  end
+
+  def test_request_with_authentication_and_pattern_handles_case_insensitivity
+    FakeWeb.register_uri(:get, %r|http://user:pass@mock/example\.\w+|i, :body => "example")
+    http = Net::HTTP.new('mock', 80)
+    req = Net::HTTP::Get.new('/example.txt')
+    req.basic_auth 'uSeR', 'PAss'
+    assert_equal "example", http.request(req).body
+  end
+
+  def test_requesting_a_uri_that_matches_two_registered_regexes_raises_an_error
+    FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "first")
+    FakeWeb.register_uri(:get, %r|http://example\.com/a|, :body => "second")
+    assert_raise FakeWeb::MultipleMatchingRegexpsError do
+      Net::HTTP.start("example.com") { |query| query.get('/a') }
+    end
+  end
+
+  def test_requesting_a_uri_that_matches_two_registered_regexes_raises_an_error_including_request_info
+    FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "first")
+    FakeWeb.register_uri(:get, %r|http://example\.com/a|, :body => "second")
+    begin
+      Net::HTTP.start("example.com") { |query| query.get('/a') }
+    rescue FakeWeb::MultipleMatchingRegexpsError => exception
+    end
+    assert exception.message.include?("GET http://example.com/a")
+  end
+
+  def test_registry_does_not_find_using_mismatched_protocols_or_ports_when_registered_with_both
+    FakeWeb.register_uri(:get, %r|http://www.example.com:80|, :body => "example")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:80")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com:443")
+  end
+
+  def test_registry_only_finds_using_default_port_when_registered_without_if_protocol_matches
+    FakeWeb.register_uri(:get, %r|http://www.example.com/test|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80/test")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com:443/test")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:443/test")
+    FakeWeb.register_uri(:get, %r|https://www.example.org/test|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.org:443/test")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.org:80/test")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.org:80/test")
+  end
+
+  def test_registry_matches_using_mismatched_port_when_registered_without
+    FakeWeb.register_uri(:get, %r|http://www.example.com|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:443")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:12345")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:443")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com")
+  end
+
+  def test_registry_matches_using_any_protocol_and_port_when_registered_without_protocol_or_port
+    FakeWeb.register_uri(:get, %r|www.example.com|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:443")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:80")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:443")
+  end
+
+  def test_registry_matches_with_query_params
+    FakeWeb.register_uri(:get, %r[example.com/list\?(.*&|)important=1], :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?hash=123&important=1&unimportant=2")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?hash=123&important=12&unimportant=2")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?important=1&unimportant=2")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/list?important=2")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/list?important=2&unimportant=1")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/list?hash=123&important=2&unimportant=1")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/list?notimportant=1&unimportant=1")
+  end
+end

data/vendor/fakeweb/test/test_response_headers.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestResponseHeaders < Test::Unit::TestCase
+
+  def test_content_type_when_registering_with_string_and_content_type_header_as_symbol_option
+    FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]', :content_type => "application/json")
+    response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }
+    assert_equal '[{"username": "chrisk"}]', response.body
+    assert_equal "application/json", response['Content-Type']
+  end
+
+  def test_content_type_when_registering_with_string_and_content_type_header_as_string_option
+    FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]', 'Content-Type' => "application/json")
+    response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }
+    assert_equal "application/json", response['Content-Type']
+  end
+
+  def test_content_type_when_registering_with_string_only
+    FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]')
+    response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }
+    assert_equal '[{"username": "chrisk"}]', response.body
+    assert_nil response['Content-Type']
+  end
+
+  def test_cookies_when_registering_with_file_and_set_cookie_header
+    FakeWeb.register_uri(:get, "http://example.com/", :body => File.dirname(__FILE__) + '/fixtures/test_example.txt',
+                                                      :set_cookie => "user_id=1; example=yes")
+    response = Net::HTTP.start("example.com") { |query| query.get("/") }
+    assert_equal "test example content", response.body
+    assert_equal "user_id=1; example=yes", response['Set-Cookie']
+  end
+
+  def test_registering_with_baked_response_ignores_header_options
+    fake_response = Net::HTTPOK.new('1.1', '200', 'OK')
+    fake_response["Server"] = "Apache/1.3.27 (Unix)"
+    FakeWeb.register_uri(:get, "http://example.com/", :response => fake_response,
+                                                      :server => "FakeWeb/1.2.3 (Ruby)")
+    response = Net::HTTP.start("example.com") { |query| query.get("/") }
+    assert_equal "200", response.code
+    assert_equal "OK", response.message
+    assert_equal "Apache/1.3.27 (Unix)", response["Server"]
+  end
+
+  def test_headers_are_rotated_when_registering_with_response_rotation
+    FakeWeb.register_uri(:get, "http://example.com",
+                               [{:body => 'test1', :expires => "Thu, 14 Jun 2009 16:00:00 GMT",
+                                                   :content_type => "text/plain"},
+                                {:body => 'test2', :expires => "Thu, 14 Jun 2009 16:00:01 GMT"}])
+
+    first_response = second_response = nil
+    Net::HTTP.start("example.com") do |query|
+      first_response = query.get("/")
+      second_response = query.get("/")
+    end
+    assert_equal 'test1', first_response.body
+    assert_equal "Thu, 14 Jun 2009 16:00:00 GMT", first_response['Expires']
+    assert_equal "text/plain", first_response['Content-Type']
+    assert_equal 'test2', second_response.body
+    assert_equal "Thu, 14 Jun 2009 16:00:01 GMT", second_response['Expires']
+    assert_nil second_response['Content-Type']
+  end
+
+  def test_registering_with_status_option_and_response_headers
+    FakeWeb.register_uri(:get, "http://example.com", :status => ["301", "Moved Permanently"],
+                                                     :location => "http://www.example.com")
+
+    response = Net::HTTP.start("example.com") { |query| query.get("/") }
+    assert_equal "301", response.code
+    assert_equal "Moved Permanently", response.message
+    assert_equal "http://www.example.com", response["Location"]
+  end
+
+end

data/vendor/fakeweb/test/test_trailing_slashes.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestFakeWebTrailingSlashes < Test::Unit::TestCase
+
+  def test_registering_root_without_slash_and_ask_predicate_method_with_slash
+    FakeWeb.register_uri(:get, "http://www.example.com", :body => "root")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com/")
+  end
+
+  def test_registering_root_without_slash_and_request
+    FakeWeb.register_uri(:get, "http://www.example.com", :body => "root")
+    response = Net::HTTP.start("www.example.com") { |query| query.get('/') }
+    assert_equal "root", response.body
+  end
+
+  def test_registering_root_with_slash_and_ask_predicate_method_without_slash
+    FakeWeb.register_uri(:get, "http://www.example.com/", :body => "root")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com")
+  end
+
+  def test_registering_root_with_slash_and_request
+    FakeWeb.register_uri(:get, "http://www.example.com/", :body => "root")
+    response = Net::HTTP.start("www.example.com") { |query| query.get('/') }
+    assert_equal "root", response.body
+  end
+
+  def test_registering_path_without_slash_and_ask_predicate_method_with_slash
+    FakeWeb.register_uri(:get, "http://www.example.com/users", :body => "User list")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com/users/")
+  end
+
+  def test_registering_path_without_slash_and_request_with_slash
+    FakeWeb.allow_net_connect = false
+    FakeWeb.register_uri(:get, "http://www.example.com/users", :body => "User list")
+    assert_raise FakeWeb::NetConnectNotAllowedError do
+      response = Net::HTTP.start("www.example.com") { |query| query.get('/users/') }
+    end
+  end
+
+  def test_registering_path_with_slash_and_ask_predicate_method_without_slash
+    FakeWeb.register_uri(:get, "http://www.example.com/users/", :body => "User list")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com/users")
+  end
+
+  def test_registering_path_with_slash_and_request_without_slash
+    FakeWeb.allow_net_connect = false
+    FakeWeb.register_uri(:get, "http://www.example.com/users/", :body => "User list")
+    assert_raise FakeWeb::NetConnectNotAllowedError do
+      response = Net::HTTP.start("www.example.com") { |query| query.get('/users') }
+    end
+  end
+
+end

data/vendor/fakeweb/test/test_utility.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestUtility < Test::Unit::TestCase
+
+  def test_decode_userinfo_from_header_handles_basic_auth
+    authorization_header = "Basic dXNlcm5hbWU6c2VjcmV0"
+    userinfo = FakeWeb::Utility.decode_userinfo_from_header(authorization_header)
+    assert_equal "username:secret", userinfo
+  end
+
+  def test_encode_unsafe_chars_in_userinfo_does_not_encode_userinfo_safe_punctuation
+    userinfo = "user;&=+$,:secret"
+    assert_equal userinfo, FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo)
+  end
+
+  def test_encode_unsafe_chars_in_userinfo_does_not_encode_rfc_3986_unreserved_characters
+    userinfo = "-_.!~*'()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:secret"
+    assert_equal userinfo, FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo)
+  end
+
+  def test_encode_unsafe_chars_in_userinfo_does_encode_other_characters
+    userinfo, safe_userinfo = 'us#rn@me:sec//ret?"', 'us%23rn%40me:sec%2F%2Fret%3F%22'
+    assert_equal safe_userinfo, FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo)
+  end
+
+  def test_strip_default_port_from_uri_strips_80_from_http_with_path
+    uri = "http://example.com:80/foo/bar"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "http://example.com/foo/bar", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_strips_80_from_http_without_path
+    uri = "http://example.com:80"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "http://example.com", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_strips_443_from_https_without_path
+    uri = "https://example.com:443"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "https://example.com", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_strips_443_from_https
+    uri = "https://example.com:443/foo/bar"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "https://example.com/foo/bar", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_does_not_strip_8080_from_http
+    uri = "http://example.com:8080/foo/bar"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+  def test_strip_default_port_from_uri_does_not_strip_443_from_http
+    uri = "http://example.com:443/foo/bar"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+  def test_strip_default_port_from_uri_does_not_strip_80_from_query_string
+    uri = "http://example.com/?a=:80&b=c"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+  def test_strip_default_port_from_uri_does_not_modify_strings_that_do_not_start_with_http_or_https
+    uri = "httpz://example.com:80/"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+end

data/vendor/json-1.1.3/CHANGES

@@ -0,0 +1,93 @@
+2008-07-10 (1.1.3)
+  * Wesley Beary <monki@geemus.com> reported a bug in json/add/core's DateTime
+    handling: If the nominator and denominator of the offset were divisible by
+    each other Ruby's Rational#to_s returns them as an integer not a fraction
+    with '/'. This caused a ZeroDivisionError during parsing.
+  * Use Date#start and DateTime#start instead of sg method, while
+    remaining backwards compatible.
+  * Supports ragel >= 6.0 now.
+  * Corrected some tests.
+  * Some minor changes.
+2007-11-27 (1.1.2)
+  * Remember default dir (last used directory) in editor.
+  * JSON::Editor.edit method added, the editor can now receive json texts from
+    the clipboard via C-v.
+  * Load json texts from an URL pasted via middle button press.
+  * Added :create_additions option to Parser. This makes it possible to disable
+    the creation of additions by force, in order to treat json texts as data
+    while having additions loaded.
+  * Jacob Maine <jmaine@blurb.com> reported, that JSON(:foo) outputs a JSON
+    object if the rails addition is enabled, which is wrong. It now outputs a
+    JSON string "foo" instead, like suggested by Jacob Maine.
+  * Discovered a bug in the Ruby Bugs Tracker on rubyforge, that was reported
+    by John Evans lgastako@gmail.com. He could produce a crash in the JSON
+    generator by returning something other than a String instance from a
+    to_json method. I now guard against this by doing a rather crude type
+    check, which raises an exception instead of crashing.
+2007-07-06 (1.1.1)
+  * Yui NARUSE <naruse@airemix.com> sent some patches to fix tests for Ruby
+    1.9. I applied them and adapted some of them a bit to run both on 1.8 and
+    1.9.
+  * Introduced a JSON.parse! method without depth checking for people who like
+    danger.
+  * Made generate and pretty_generate methods configurable by an options hash.
+  * Added :allow_nan option to parser and generator in order to handle NaN,
+    Infinity, and -Infinity correctly - if requested. Floats, which aren't numbers,
+    aren't valid JSON according to RFC4627, so by default an exception will be
+    raised if any of these symbols are encountered. Thanks to Andrea Censi
+    <andrea.censi@dis.uniroma1.it> for his hint about this.
+  * Fixed some more tests for Ruby 1.9.
+  * Implemented dump/load interface of Marshal as suggested in ruby-core:11405
+    by murphy <murphy@rubychan.de>.
+  * Implemented the max_nesting feature for generate methods, too.
+  * Added some implementations for ruby core's custom objects for
+    serialisation/deserialisation purposes.
+2007-05-21 (1.1.0)
+  * Implemented max_nesting feature for parser to avoid stack overflows for
+    data from untrusted sources. If you trust the source, you can disable it
+    with the option max_nesting => false.
+  * Piers Cawley <pdcawley@bofh.org.uk> reported a bug, that not every
+    character can be escaped by ?\ as required by RFC4627. There's a
+    contradiction between David Crockford's JSON checker test vectors (in
+    tests/fixtures) and RFC4627, though. I decided to stick to the RFC, because
+    the JSON checker seems to be a bit older than the RFC.
+  * Extended license to Ruby License, which includes the GPL.
+  * Added keyboard shortcuts, and 'Open location' menu item to edit_json.rb.
+2007-05-09 (1.0.4)
+  * Applied a patch from Yui NARUSE <naruse@airemix.com> to make JSON compile
+    under Ruby 1.9. Thank you very much for mailing it to me!
+  * Made binary variants of JSON fail early, instead of falling back to the
+    pure version. This should avoid overshadowing of eventual problems while
+    loading of the binary.
+2007-03-24 (1.0.3)
+  * Improved performance of pure variant a bit.
+  * The ext variant of this release supports the mswin32 platform. Ugh!
+2007-03-24 (1.0.2)
+  * Ext Parser didn't parse 0e0 correctly into 0.0: Fixed!
+2007-03-24 (1.0.1)
+  * Forgot some object files in the build dir. I really like that - not!
+2007-03-24 (1.0.0)
+  * Added C implementations for the JSON generator and a ragel based JSON
+    parser in C.
+  * Much more tests, especially fixtures from json.org.
+  * Further improved conformance to RFC4627.
+2007-02-09 (0.4.3)
+  * Conform more to RFC4627 for JSON: This means JSON strings
+    now always must contain exactly one object "{ ... }" or array "[ ... ]" in
+    order to be parsed without raising an exception. The definition of what
+    constitutes a whitespace is narrower in JSON than in Ruby ([ \t\r\n]), and
+    there are differences in floats and integers (no octals or hexadecimals) as
+    well.
+  * Added aliases generate and pretty_generate of unparse and pretty_unparse.
+  * Fixed a test case.
+  * Catch an Iconv::InvalidEncoding exception, that seems to occur on some Sun
+    boxes with SunOS 5.8, if iconv doesn't support utf16 conversions. This was
+    reported by Andrew R Jackson <andrewj@bcm.tmc.edu>, thanks a bunch!
+2006-08-25 (0.4.2)
+  * Fixed a bug in handling solidi (/-characters), that was reported by
+    Kevin Gilpin <kevin.gilpin@alum.mit.edu>.
+2006-02-06 (0.4.1)
+  * Fixed a bug related to escaping with backslashes. Thanks for the report go
+    to Florian Munz <surf@theflow.de>.
+2005-09-23 (0.4.0)
+  * Initial Rubyforge Version