ivanvr-fakeweb 1.2.5.3

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

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

@@ -0,0 +1,91 @@
+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
+
+  def test_simple_array_permutation_with_one_element
+    array, permutations = [1], [[1]]
+    FakeWeb::Utility.simple_array_permutation(array) do |permutation|
+      permutations.delete(permutation)
+    end
+    assert permutations.empty?
+  end
+
+  def test_simple_array_permutation_with_three_elements
+    array = [1, 2, 3]
+    permutations = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
+    FakeWeb::Utility.simple_array_permutation(array) do |permutation|
+      permutations.delete(permutation)
+    end
+    assert permutations.empty?
+  end
+
+  def test_simple_array_permutation_return_value
+    array = [1, 2, 3]
+    assert array, FakeWeb::Utility.simple_array_permutation(array) { }
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: ivanvr-fakeweb
+version: !ruby/object:Gem::Version 
+  version: 1.2.5.3
+platform: ruby
+authors: 
+- Chris Kampmeier
+- Blaine Cook
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.5
+    version: 
+description: FakeWeb is a helper for faking web requests in Ruby. It works at a global level, without modifying code or writing extensive stubs.
+email: 
+- chris@kampers.net
+- romeda@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- LICENSE.txt
+- README.rdoc
+files: 
+- CHANGELOG
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib
+- lib/fake_web
+- lib/fake_web.rb
+- lib/fake_web/ext
+- lib/fake_web/ext/net_http.rb
+- lib/fake_web/registry.rb
+- lib/fake_web/responder.rb
+- lib/fake_web/response.rb
+- lib/fake_web/stub_socket.rb
+- lib/fake_web/utility.rb
+- lib/fakeweb.rb
+- test
+- test/fixtures
+- test/fixtures/google_response_from_curl
+- test/fixtures/google_response_with_transfer_encoding
+- test/fixtures/google_response_without_transfer_encoding
+- test/fixtures/test_example.txt
+- test/fixtures/test_txt_file
+- test/test_allow_net_connect.rb
+- test/test_deprecations.rb
+- test/test_fake_authentication.rb
+- test/test_fake_web.rb
+- test/test_fake_web_open_uri.rb
+- test/test_helper.rb
+- test/test_missing_open_uri.rb
+- test/test_precedence.rb
+- test/test_query_string.rb
+- test/test_regexes.rb
+- test/test_response_headers.rb
+- test/test_trailing_slashes.rb
+- test/test_utility.rb
+has_rdoc: true
+homepage: http://github.com/ivanvr/fakeweb
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --title
+- FakeWeb API Documentation
+- --charset
+- utf-8
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: A tool for faking responses to HTTP requests
+test_files: 
+- test/fixtures
+- test/fixtures/google_response_from_curl
+- test/fixtures/google_response_with_transfer_encoding
+- test/fixtures/google_response_without_transfer_encoding
+- test/fixtures/test_example.txt
+- test/fixtures/test_txt_file
+- test/test_allow_net_connect.rb
+- test/test_deprecations.rb
+- test/test_fake_authentication.rb
+- test/test_fake_web.rb
+- test/test_fake_web_open_uri.rb
+- test/test_helper.rb
+- test/test_missing_open_uri.rb
+- test/test_precedence.rb
+- test/test_query_string.rb
+- test/test_regexes.rb
+- test/test_response_headers.rb
+- test/test_trailing_slashes.rb
+- test/test_utility.rb