messagebus_ruby_api 0.4.7 → 0.4.8

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_fake_web_open_uri.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-class TestFakeWebOpenURI < Test::Unit::TestCase
-
-  def test_content_for_registered_uri
-    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => fixture_path("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 => fixture_path("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 => fixture_path("test_example.txt"))
-    body = open('http://mock/test_example.txt') { |f| f.readlines }
-    assert_equal 'test example content', body.first
-  end
-end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_helper.rb

@@ -1,90 +0,0 @@
-require 'test/unit'
-require 'open-uri'
-require 'pathname'
-require 'fake_web'
-require 'rbconfig'
-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 fixture_path(basename)
-    "test/fixtures/#{basename}"
-  end
-
-  def capture_stderr
-    $stderr = StringIO.new
-    yield
-    $stderr.rewind && $stderr.read
-  ensure
-    $stderr = STDERR
-  end
-
-  # The path to the current ruby interpreter. Adapted from Rake's FileUtils.
-  def ruby_path
-    ext = ((RbConfig::CONFIG['ruby_install_name'] =~ /\.(com|cmd|exe|bat|rb|sh)$/) ? "" : RbConfig::CONFIG['EXEEXT'])
-    File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'] + ext).sub(/.*\s.*/m, '"\&"')
-  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).at_least_once.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)
-    if !options[:request_body].nil?
-      socket.expects(:write).with(options[:request_body]).returns(100)
-    end
-
-    read_method = RUBY_VERSION >= "1.9.2" ? :read_nonblock : :sysread
-    socket.expects(read_method).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/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_last_request.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class TestLastRequest < Test::Unit::TestCase
-
-  def test_last_request_returns_correct_net_http_request_class
-    FakeWeb.register_uri(:get, "http://example.com", :status => [200, "OK"])
-    Net::HTTP.start("example.com") { |http| http.get("/") }
-    assert_instance_of Net::HTTP::Get, FakeWeb.last_request
-  end
-
-  def test_last_request_has_correct_method_path_and_body_for_get
-    FakeWeb.register_uri(:get, "http://example.com", :status => [200, "OK"])
-    Net::HTTP.start("example.com") { |http| http.get("/") }
-    assert_equal "GET", FakeWeb.last_request.method
-    assert_equal "/", FakeWeb.last_request.path
-    assert_nil FakeWeb.last_request.body
-    assert_nil FakeWeb.last_request.content_length
-  end
-
-  def test_last_request_has_correct_method_path_and_body_for_post
-    FakeWeb.register_uri(:post, "http://example.com/posts", :status => [201, "Created"])
-    Net::HTTP.start("example.com") { |http| http.post("/posts", "title=Test") }
-    assert_equal "POST", FakeWeb.last_request.method
-    assert_equal "/posts", FakeWeb.last_request.path
-    assert_equal "title=Test", FakeWeb.last_request.body
-    assert_equal 10, FakeWeb.last_request.content_length
-  end
-
-end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_missing_open_uri.rb

@@ -1,25 +0,0 @@
-require '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/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_missing_pathname.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class TestMissingPathname < Test::Unit::TestCase
-
-  def setup
-    super
-    @saved_pathname = Pathname
-    Object.send(:remove_const, :Pathname)
-  end
-
-  def teardown
-    super
-    Object.const_set(:Pathname, @saved_pathname)
-  end
-
-  # FakeWeb supports using Pathname objects where filenames are expected, but
-  # Pathname isn't required to use FakeWeb. Make sure everything still works
-  # when Pathname isn't in use.
-
-  def test_register_using_body_without_pathname
-    FakeWeb.register_uri(:get, "http://example.com/", :body => fixture_path("test_example.txt"))
-    Net::HTTP.start("example.com") { |http| http.get("/") }
-  end
-
-  def test_register_using_response_without_pathname
-    FakeWeb.register_uri(:get, "http://example.com/", :response => fixture_path("google_response_without_transfer_encoding"))
-    Net::HTTP.start("example.com") { |http| http.get("/") }
-  end
-
-  def test_register_using_unsupported_response_without_pathname
-    FakeWeb.register_uri(:get, "http://example.com/", :response => 1)
-    assert_raise StandardError do
-      Net::HTTP.start("example.com") { |http| http.get("/") }
-    end
-  end
-
-end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_other_net_http_libraries.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-class TestOtherNetHttpLibraries < Test::Unit::TestCase
-
-  def capture_output_from_requiring(libs, additional_code = "")
-    requires = libs.map { |lib| "require '#{lib}'" }.join("; ")
-    fakeweb_dir = "#{File.dirname(__FILE__)}/../lib"
-    vendor_dirs = Dir["#{File.dirname(__FILE__)}/vendor/*/lib"]
-    load_path_opts = vendor_dirs.unshift(fakeweb_dir).map { |dir| "-I#{dir}" }.join(" ")
-
-    `#{ruby_path} #{load_path_opts} -e "#{requires}; #{additional_code}" 2>&1`
-  end
-
-  def test_requiring_samuel_before_fakeweb_prints_warning
-    output = capture_output_from_requiring %w(samuel fakeweb)
-    assert_match %r(Warning: FakeWeb was loaded after Samuel), output
-  end
-
-  def test_requiring_samuel_after_fakeweb_does_not_print_warning
-    output = capture_output_from_requiring %w(fakeweb samuel)
-    assert output.empty?
-  end
-
-  def test_requiring_right_http_connection_before_fakeweb_and_then_connecting_does_not_print_warning
-    additional_code = "Net::HTTP.start('example.com')"
-    output = capture_output_from_requiring %w(right_http_connection fakeweb), additional_code
-    assert output.empty?
-  end
-
-  def test_requiring_right_http_connection_after_fakeweb_and_then_connecting_prints_warning
-    additional_code = "Net::HTTP.start('example.com')"
-    output = capture_output_from_requiring %w(fakeweb right_http_connection), additional_code
-    assert_match %r(Warning: RightHttpConnection was loaded after FakeWeb), output
-  end
-
-end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_precedence.rb

@@ -1,79 +0,0 @@
-require '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/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_query_string.rb

@@ -1,45 +0,0 @@
-require '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/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/test_regexes.rb

@@ -1,157 +0,0 @@
-require '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_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_does_not_match_when_regex_has_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
-
-  def test_registry_matches_when_regex_has_sorted_query_params
-    FakeWeb.register_uri(:get, %r[example\.com/list\?a=1&b=2], :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
-
-  def test_registry_matches_quickly_with_lots_of_query_params
-    # regression test for code that tried to calculate the permutations of the
-    # query params, which hangs with a large number of params
-    FakeWeb.register_uri(:get, %r[example.com], :body => "example")
-    Timeout::timeout(1) do
-      FakeWeb.registered_uri?(:get, "http://example.com/?a=1&b=2&c=3&d=4&e=5&f=6&g=7&h=8")
-    end
-  end
-
-end