sandro-fakeweb 1.2.5

data/test/test_fake_web_fixture.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestFakeWebFixture < Test::Unit::TestCase
+  def setup
+    @response = Net::HTTPOK.new("1.1", "200", "OK")
+    @path = "."
+    @fixture = FakeWeb::Fixture.new(@path, :get, "http://www.apple.com", @response)
+  end
+
+  def test_register_fixtures_in_path
+    fixture = mock(:register => true)
+    YAML.expects(:load_file).with('file').returns(fixture)
+    Dir.expects(:glob).yields('file')
+    FakeWeb::Fixture.register(@path)
+  end
+
+  def test_register_fixture_with_fake_web
+    FakeWeb.expects(:register_uri).with(:get, "http://www.apple.com", :response => @response)
+    @fixture.register
+  end
+
+  def test_file_name_without_path
+    assert_equal @fixture.file_name, "GET_www.apple.com.fixture"
+  end
+
+  def test_file_name_with_path_and_querystring
+    url = "http://www.apple.com/iphone/why-iphone/?q=iphone&other=i%20phone"
+    fixture = FakeWeb::Fixture.new(@path, :get, url, stub)
+    assert_equal fixture.file_name, "GET_www.apple.com-iphone-why-iphone.fixture"
+  end
+
+  def test_duplicate_file_name_increments_number_identifier
+    File.new('GET_www.apple.com.fixture', 'w')
+    assert_equal @fixture.file_name, "GET_www.apple.com_2.fixture"
+    File.unlink('GET_www.apple.com.fixture')
+  end
+
+  def test_unique_file_name_when_integer_does_not_exist
+    File.new('original.txt', 'w')
+
+    fixture = FakeWeb::Fixture.allocate
+    assert_equal fixture.send(:next_unique_file_name, "original.txt"), "original_2.txt"
+
+    File.unlink('original.txt')
+  end
+
+  def test_unique_file_name_when_integer_exists
+    File.new('original.txt', 'w')
+    File.new('original_2.txt', 'w')
+
+    fixture = FakeWeb::Fixture.allocate
+    assert_equal fixture.send(:next_unique_file_name, "original.txt"), "original_3.txt"
+
+    File.unlink('original.txt')
+    File.unlink('original_2.txt')
+  end
+
+  def test_save
+    file = stub
+    File.expects(:open).with(@fixture.file_name, 'w').yields(file)
+    file.expects(:write).with(@fixture.to_yaml)
+    @fixture.save
+  end
+end

data/test/test_fake_web_generate_fixtures.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+require 'fileutils'
+
+class TestFakeWebGenerateFixture < Test::Unit::TestCase
+  def setup
+    @path = File.dirname(__FILE__) + "/fixtures/tmp"
+    Dir.mkdir(@path)
+  end
+
+  def teardown
+    FileUtils.rm_rf @path
+    FakeWeb.allow_net_connect = true
+  end
+
+  def test_raise_error_when_path_invalid
+    assert_raise RuntimeError do
+      FakeWeb.generate_fixtures("invalid_path")
+    end
+  end
+
+  def test_save_and_restore_one_fixture
+    FakeWeb.generate_fixtures(@path)
+    request = lambda { Net::HTTP.get_response URI.parse("http://www.google.com") }
+    setup_basic_response_for_request
+    real_response = request.call
+
+    FakeWeb.register_fixtures(@path)
+    FakeWeb.allow_net_connect = false
+    assert_nothing_raised do
+      assert_equal real_response.body, request.call.body
+    end
+  end
+
+  def test_save_and_restore_multiple_fixtures
+    FakeWeb.generate_fixtures(@path)
+    setup_basic_response_for_request
+    setup_basic_response_for_request :path => "/news/ipod.rss", :response_body => "iPod news"
+    setup_basic_response_for_request :path => "/news/iphone.rss", :response_body => "iPhone news"
+    requests = lambda do
+      Net::HTTP.get_response URI.parse("http://www.google.com")
+      Net::HTTP.get_response URI.parse("http://www.google.com/news/ipod.rss")
+      Net::HTTP.get_response URI.parse("http://www.google.com/news/iphone.rss")
+    end
+    requests.call
+
+    FakeWeb.register_fixtures(@path)
+    FakeWeb.allow_net_connect = false
+    assert_nothing_raised do
+      requests.call
+    end
+  end
+
+  def test_restoring_fixtures_stops_generating_fixtures
+    FakeWeb.register_fixtures(@path)
+    assert ! FakeWeb.generate_fixtures?
+  end
+
+  def test_generating_fixtures_allows_net_connections
+    FakeWeb.allow_net_connect = false
+    FakeWeb.generate_fixtures(@path)
+    assert FakeWeb.allow_net_connect?
+  end
+
+  def test_compatibility_with_open_uri
+    FakeWeb.generate_fixtures(@path)
+    setup_basic_response_for_request
+    assert_nothing_raised TypeError, "no marshal_dump is defined for class Proc" do
+      open("http://www.google.com")
+    end
+  end
+end

data/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/test/test_helper.rb

@@ -0,0 +1,87 @@
+$:.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
+  alias setup_without_fakeweb setup
+  def setup
+    FakeWeb.clean_registry
+    @original_allow_net_connect = FakeWeb.allow_net_connect?
+    FakeWeb.allow_net_connect = false
+  end
+
+  alias teardown_without_fakeweb teardown
+  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
+
+  def setup_basic_response_for_request(options = {})
+    defaults = { :host => "www.google.com", :port => 80, :method => "GET",
+                 :path => "", :response_code => 200, :response_message => "OK",
+                 :response_body => "Google" }
+    options = defaults.merge(options)
+
+    socket = stub("TCPSocket", :closed? => false, :close => true, :write => 100)
+    Socket.stubs(:===).returns(true)
+    TCPSocket.stubs(:open).returns(socket)
+    socket.stubs(:sysread).returns("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\nContent-Length: #{options[:response_body].length}\n\n#{options[:response_body]}")
+  end
+end
+
+Test::Unit::TestCase.send(:include, FakeWebTestHelper)

data/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/test/test_precedence.rb

@@ -0,0 +1,79 @@
+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
+
+  def test_identical_registration_replaces_previous_registration
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "first")
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "second", response.body
+  end
+
+  def test_identical_registration_replaces_previous_registration_accounting_for_normalization
+    FakeWeb.register_uri(:get, "http://example.com/test?", :body => "first")
+    FakeWeb.register_uri(:get, "http://example.com:80/test", :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "second", response.body
+  end
+
+  def test_identical_registration_replaces_previous_registration_accounting_for_query_params
+    FakeWeb.register_uri(:get, "http://example.com/test?a=1&b=2", :body => "first")
+    FakeWeb.register_uri(:get, "http://example.com/test?b=2&a=1", :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test?a=1&b=2') }
+    assert_equal "second", response.body
+  end
+
+  def test_identical_registration_replaces_previous_registration_with_regexes
+    FakeWeb.register_uri(:get, /test/, :body => "first")
+    FakeWeb.register_uri(:get, /test/, :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "second", response.body
+  end
+
+end

data/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/test/test_regexes.rb

@@ -0,0 +1,152 @@
+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::MultipleMatchingURIsError do
+      Net::HTTP.start("example.com") { |query| query.get('/a') }
+    end
+  end
+
+  def test_requesting_a_uri_that_matches_two_registered_regexes_with_differently_ordered_query_params_raises_an_error
+    FakeWeb.register_uri(:get, %r[example.com/list\?b=2&a=1], :body => "first")
+    FakeWeb.register_uri(:get, %r[example.com/list\?a=1&b=2], :body => "second")
+    assert_raise FakeWeb::MultipleMatchingURIsError do
+      Net::HTTP.start("example.com") { |query| query.get('/list?a=1&b=2') }
+    end
+    assert_raise FakeWeb::MultipleMatchingURIsError do
+      Net::HTTP.start("example.com") { |query| query.get('/list?b=2&a=1') }
+    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::MultipleMatchingURIsError => 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_finds_using_non_default_port
+    FakeWeb.register_uri(:get, %r|example\.com:8080|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:8080/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:8080/path")
+  end
+
+  def test_registry_finds_using_default_port_and_http_when_registered_with_explicit_port_80
+    FakeWeb.register_uri(:get, %r|example\.com:80|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com/path")
+
+    # check other permutations, too
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80/path")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:8080/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:80/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:8080/path")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com/path")
+  end
+
+  def test_registry_finds_using_default_port_and_https_when_registered_with_explicit_port_443
+    FakeWeb.register_uri(:get, %r|example\.com:443|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com/path")
+
+    # check other permutations, too
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:443/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:44321/path")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:443/path")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:44321/path")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com/path")
+  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_default_port_for_protocol_when_registered_without_protocol_or_port
+    FakeWeb.register_uri(:get, %r|www.example.com/home|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com/home")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com/home")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80/home")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:443/home")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:80/home")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com:443/home")
+  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
+
+  def test_registry_matches_with_unsorted_query_params
+    FakeWeb.register_uri(:get, %r[example\.com/list\?b=2&a=1], :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?b=2&a=1")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?a=1&b=2")
+    assert FakeWeb.registered_uri?(:get, "https://example.com:443/list?b=2&a=1")
+  end
+
+end