poolparty 1.3.15 → 1.4.0

data/vendor/gems/fakeweb/test/test_precedence.rb

@@ -1,51 +0,0 @@
-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/gems/fakeweb/test/test_query_string.rb

@@ -1,45 +0,0 @@
-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/gems/fakeweb/test/test_regexes.rb

@@ -1,103 +0,0 @@
-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/gems/fakeweb/test/test_response_headers.rb

@@ -1,73 +0,0 @@
-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/gems/fakeweb/test/test_trailing_slashes.rb

@@ -1,53 +0,0 @@
-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/gems/fakeweb/test/test_utility.rb

@@ -1,70 +0,0 @@
-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